TAO_UIPMC_Profile Class Reference

This class defines the protocol specific attributes required for locating ORBs over a TCP/IP network. More...

#include <UIPMC_Profile.h>

Inheritance diagram for TAO_UIPMC_Profile:

[legend]Collaboration diagram for TAO_UIPMC_Profile:

[legend]List of all members.

Public Member Functions
virtual char	object_key_delimiter (void) const
	TAO_UIPMC_Profile (TAO_ORB_Core *orb_core)
	TAO_UIPMC_Profile (const ACE_INET_Addr &addr, TAO_ORB_Core *orb_core)
	TAO_UIPMC_Profile (const CORBA::Octet class_d_address[4], CORBA::UShort port, TAO_ORB_Core *orb_core)
	Profile constructor.
	TAO_UIPMC_Profile (const char *string, TAO_ORB_Core *orb_core)
	Create object using a string ior.
	~TAO_UIPMC_Profile (void)
	Destructor is to be called only through .
virtual int	decode (TAO_InputCDR &cdr)
	Template methods. Please see tao/Profile.h for documentation.
virtual void	parse_string (const char *string)
virtual char *	to_string ()
virtual int	encode_endpoints (void)
virtual TAO_Endpoint *	endpoint (void)
virtual CORBA::ULong	endpoint_count (void) const
virtual CORBA::ULong	hash (CORBA::ULong max)
virtual IOP::TaggedProfile &	create_tagged_profile (void)
virtual void	request_target_specifier (TAO_Target_Specification &target_spec, TAO_Target_Specification::TAO_Target_Address r)
virtual int	supports_multicast (void) const
virtual void	addressing_mode (CORBA::Short addr_mode)
void	set_group_info (const char *domain_id, PortableGroup::ObjectGroupId group_id, PortableGroup::ObjectGroupRefVersion ref_version)
	Add the mandatory group component to this profile.
Static Public Member Functions
const char *	prefix (void)
	Return the char string prefix.
int	extract_group_component (const IOP::TaggedProfile &profile, PortableGroup::TagGroupTaggedComponent &group)
Static Public Attributes
const char	object_key_delimiter_ = '/'
	The object key delimiter that UIPMC uses or expects.
Protected Member Functions
virtual int	decode_profile (TAO_InputCDR &cdr)
	Template methods, please see documentation in tao/Profile.h.
virtual int	decode_endpoints (void)
virtual void	parse_string_i (const char *)
virtual void	create_profile_body (TAO_OutputCDR &cdr) const
virtual CORBA::Boolean	do_is_equivalent (const TAO_Profile *other_profile)
virtual void	update_cached_group_component (void)
Protected Attributes
TAO_UIPMC_Endpoint	endpoint_
CORBA::ULong	count_
	Number of endpoints in the list headed by .
Private Attributes
IOP::TaggedProfile	tagged_profile_
	Cached version of our tagged profile.
ACE_CString	group_domain_id_
	Group Domain ID.
PortableGroup::ObjectGroupId	group_id_
	Our group ID within the group domain.
PortableGroup::ObjectGroupRefVersion	ref_version_
	The group reference's version.

---

Detailed Description

This class defines the protocol specific attributes required for locating ORBs over a TCP/IP network.

This class defines the UIPMC profile as specified in the CORBA specification.

: This class inherits the ObjectKey from TAO_Profile which may not be needed at all! But lets punt on this for the timebeing.

Definition at line 51 of file UIPMC_Profile.h.

---

Constructor & Destructor Documentation

TAO_UIPMC_Profile::TAO_UIPMC_Profile (  TAO_ORB_Core *  orb_core  )

Profile constructor, default. Used when the profile contents are not yet known or when it is being decoded from an IOR. Definition at line 37 of file UIPMC_Profile.cpp. References default_addressing_mode_, TAO_DEF_GIOP_MAJOR, and TAO_DEF_GIOP_MINOR. : TAO_Profile (IOP::TAG_UIPMC, orb_core, TAO_GIOP_Message_Version (TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR)), endpoint_ (), count_ (1), tagged_profile_ () { addressing_mode_ = default_addressing_mode_; }

TAO_UIPMC_Profile::TAO_UIPMC_Profile (  const ACE_INET_Addr &  addr, TAO_ORB_Core *  orb_core )

Profile constructor, same as above except the object_key has already been marshaled. Definition at line 48 of file UIPMC_Profile.cpp. References default_addressing_mode_, TAO_DEF_GIOP_MAJOR, and TAO_DEF_GIOP_MINOR. : TAO_Profile (IOP::TAG_UIPMC, orb_core, TAO_GIOP_Message_Version (TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR)), endpoint_ (addr), count_ (1), tagged_profile_ () { addressing_mode_ = default_addressing_mode_; }

TAO_UIPMC_Profile::TAO_UIPMC_Profile (  const CORBA::Octet  class_d_address[4], CORBA::UShort  port, TAO_ORB_Core *  orb_core )

Profile constructor. Definition at line 60 of file UIPMC_Profile.cpp. References default_addressing_mode_, TAO_DEF_GIOP_MAJOR, and TAO_DEF_GIOP_MINOR. : TAO_Profile (IOP::TAG_UIPMC, orb_core, TAO_GIOP_Message_Version (TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR)), endpoint_ (class_d_address, port), count_ (1), tagged_profile_ () { addressing_mode_ = default_addressing_mode_; }

TAO_UIPMC_Profile::TAO_UIPMC_Profile (  const char *  string, TAO_ORB_Core *  orb_core )

Create object using a string ior.

TAO_UIPMC_Profile::~TAO_UIPMC_Profile (  void   )

Destructor is to be called only through . Definition at line 103 of file UIPMC_Profile.cpp. { }

---

Member Function Documentation

void TAO_UIPMC_Profile::addressing_mode (  CORBA::Short  addr_mode  )  [virtual]

Reimplemented from TAO_Profile. Definition at line 697 of file UIPMC_Profile.cpp. References ACE_THROW. { // ** See race condition note about addressing mode in Profile.h ** switch (addr_mode) { case TAO_Target_Specification::Profile_Addr: case TAO_Target_Specification::Reference_Addr: this->addressing_mode_ = addr_mode; break; case TAO_Target_Specification::Key_Addr: // There is no object key, so it is not supported. default: ACE_THROW (CORBA::BAD_PARAM ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, EINVAL), CORBA::COMPLETED_NO)); } }

void TAO_UIPMC_Profile::create_profile_body (  TAO_OutputCDR &  cdr  )  const [protected, virtual]

Implements TAO_Profile. Definition at line 523 of file UIPMC_Profile.cpp. References TAO_Tagged_Components::encode(), TAO_Profile::tagged_components(), TAO_ENCAP_BYTE_ORDER, ACE_OutputCDR::write_octet(), ACE_OutputCDR::write_string(), and ACE_OutputCDR::write_ushort(). Referenced by create_tagged_profile(). { encap.write_octet (TAO_ENCAP_BYTE_ORDER); // The GIOP version // Note: Only GIOP 1.2 and above are supported currently for MIOP. encap.write_octet (this->version_.major); encap.write_octet (this->version_.minor); // Address. encap.write_string (this->endpoint_.get_host_addr ()); // Port number. encap.write_ushort (this->endpoint_.port ()); // UIPMC is only supported by versions of GIOP that have tagged components, // so unconditionally encode the components. this->tagged_components ().encode (encap); }

IOP::TaggedProfile & TAO_UIPMC_Profile::create_tagged_profile (  void   )  [virtual]

Reimplemented from TAO_Profile. Definition at line 483 of file UIPMC_Profile.cpp. References ACE_OutputCDR::begin(), create_profile_body(), ACE_OutputCDR::end(), TAO::unbounded_value_sequence< T >::get_buffer(), ACE_Message_Block::length(), TAO::unbounded_value_sequence< T >::length(), ACE_OS::memcpy(), ACE_Message_Block::next(), IOP::TaggedProfile::profile_data, ACE_Message_Block::rd_ptr(), TAO::unbounded_value_sequence< T >::replace(), IOP::TaggedProfile::tag, and ACE_OutputCDR::total_length(). { // Check whether we have already created the TaggedProfile if (this->tagged_profile_.profile_data.length () == 0) { // As we have not created we will now create the TaggedProfile this->tagged_profile_.tag = IOP::TAG_UIPMC; // Create the encapsulation.... TAO_OutputCDR encap; // Create the profile body this->create_profile_body (encap); CORBA::ULong length = static_cast<CORBA::ULong> (encap.total_length ()); #if (TAO_NO_COPY_OCTET_SEQUENCES == 1) // Place the message block in to the Sequence of Octets that we // have this->tagged_profile_.profile_data.replace (length, encap.begin ()); #else this->tagged_profile_.profile_data.length (length); CORBA::Octet *buffer = this->tagged_profile_.profile_data.get_buffer (); for (const ACE_Message_Block *i = encap.begin (); i != encap.end (); i = i->next ()) { ACE_OS::memcpy (buffer, i->rd_ptr (), i->length ()); buffer += i->length (); } #endif /* TAO_NO_COPY_OCTET_SEQUENCES == 1 */ } return this->tagged_profile_; }

int TAO_UIPMC_Profile::decode (  TAO_InputCDR &  cdr  )  [virtual]

Template methods. Please see tao/Profile.h for documentation. N.B. We have to override the TAO_Profile default decode because in UIPMC there is no object key marshalled and we do not implement a useable ::decode_endpoints Reimplemented from TAO_Profile. Definition at line 108 of file UIPMC_Profile.cpp. References ACE_DEBUG, ACE_TEXT(), TAO_Tagged_Components::decode(), decode_profile(), ACE_InputCDR::length(), LM_DEBUG, TAO_GIOP_Message_Version::major, TAO_GIOP_Message_Version::minor, ACE_InputCDR::read_octet(), TAO_debug_level, TAO_DEF_GIOP_MAJOR, and TAO_DEF_GIOP_MINOR. { // The following is a selective reproduction of TAO_Profile::decode CORBA::ULong encap_len = cdr.length (); // Read and verify major, minor versions, ignoring profiles // whose versions we don't understand. if (!(cdr.read_octet (this->version_.major) && this->version_.major == TAO_DEF_GIOP_MAJOR && cdr.read_octet (this->version_.minor) && this->version_.minor <= TAO_DEF_GIOP_MINOR)) { if (TAO_debug_level > 0) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - Profile::decode - v%d.%d\n"), this->version_.major, this->version_.minor)); } return -1; } // Transport specific details if (this->decode_profile (cdr) < 0) { return -1; } // UIPMC profiles must have tagged components. if (this->tagged_components_.decode (cdr) == 0) { return -1; } if (cdr.length () != 0 && TAO_debug_level) { // If there is extra data in the profile we are supposed to // ignore it, but print a warning just in case... ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%d bytes out of %d left after profile data\n"), cdr.length (), encap_len)); } // We don't call ::decode_endpoints because it is implemented // as ACE_NOTSUP_RETURN (-1) for this profile return 1; }

int TAO_UIPMC_Profile::decode_endpoints (  void   )  [protected, virtual]

Implements TAO_Profile. Definition at line 161 of file UIPMC_Profile.cpp. References ACE_NOTSUP_RETURN. { ACE_NOTSUP_RETURN (-1); }

int TAO_UIPMC_Profile::decode_profile (  TAO_InputCDR &  cdr  )  [protected, virtual]

Template methods, please see documentation in tao/Profile.h. Implements TAO_Profile. Definition at line 167 of file UIPMC_Profile.cpp. References ACE_CString, ACE_DEBUG, ACE_TEXT(), ACE_InputCDR::good_bit(), LM_DEBUG, TAO_UIPMC_Endpoint::object_addr(), ACE_InputCDR::read_string(), ACE_InputCDR::read_ushort(), and TAO_debug_level. Referenced by decode(). { CORBA::UShort port = 0; ACE_CString address; if (!(cdr.read_string (address) && cdr.read_ushort (port))) { if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) UIPMC_Profile::decode - ") ACE_TEXT ("Couldn't unmarshal address and port!\n"))); return -1; } if (cdr.good_bit ()) { // If everything was successful, update the endpoint's address // and port with the new data. ACE_INET_Addr addr (port, address.c_str ()); this->endpoint_.object_addr (addr); return 1; } return -1; }

CORBA::Boolean TAO_UIPMC_Profile::do_is_equivalent (  const TAO_Profile *  other_profile  )  [protected, virtual]

Implements TAO_Profile. Definition at line 407 of file UIPMC_Profile.cpp. References endpoint_, and TAO_UIPMC_Endpoint::is_equivalent(). { const TAO_UIPMC_Profile *op = dynamic_cast<const TAO_UIPMC_Profile *> (other_profile); if (op == 0) return 0; return this->endpoint_.is_equivalent (&op->endpoint_); }

int TAO_UIPMC_Profile::encode_endpoints (  void   )  [virtual]

Implements TAO_Profile. Definition at line 438 of file UIPMC_Profile.cpp. { return 1; }

TAO_Endpoint * TAO_UIPMC_Profile::endpoint (  void   )  [virtual]

Implements TAO_Profile. Definition at line 432 of file UIPMC_Profile.cpp. { return &this->endpoint_; }

CORBA::ULong TAO_UIPMC_Profile::endpoint_count (  void   )  const [virtual]

Implements TAO_Profile. Definition at line 444 of file UIPMC_Profile.cpp. { return 1; }

int TAO_UIPMC_Profile::extract_group_component (  const IOP::TaggedProfile &  profile, PortableGroup::TagGroupTaggedComponent &  group )  [static]

Definition at line 721 of file UIPMC_Profile.cpp. References ACE_CString, ACE_DEBUG, ACE_TEXT(), IOP::TaggedComponent::component_data, TAO_Tagged_Components::decode(), TAO::unbounded_value_sequence< T >::get_buffer(), TAO_Tagged_Components::get_component(), TAO::unbounded_value_sequence< T >::length(), LM_DEBUG, CORBA::Octet, IOP::TaggedProfile::profile_data, ACE_InputCDR::read_octet(), ACE_InputCDR::read_string(), ACE_InputCDR::read_ushort(), ACE_InputCDR::reset_byte_order(), IOP::TaggedComponent::tag, and TAO_debug_level. Referenced by PortableGroup_Request_Dispatcher::dispatch(). { // Create the decoding stream from the encapsulation in the buffer, //#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) // TAO_InputCDR cdr (profile.profile_data.mb ()); //#else TAO_InputCDR cdr (reinterpret_cast<const char*> (profile.profile_data.get_buffer ()), profile.profile_data.length ()); //#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 1 */ // Extract the Byte Order. CORBA::Boolean byte_order; if ((cdr >> ACE_InputCDR::to_boolean (byte_order)) == 0) return -1; cdr.reset_byte_order (static_cast<int> (byte_order)); // Read and verify major, minor versions, ignoring UIPMC profiles // whose versions we don't understand. CORBA::Octet major; CORBA::Octet minor = CORBA::Octet(); // Read the version. We just read it here. We don't*do any* // processing. if (!(cdr.read_octet (major) && cdr.read_octet (minor))) { if (TAO_debug_level > 0) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) UIPMC_Profile::extract_group_component - v%d.%d\n"), major, minor)); } return -1; } // Decode the endpoint. ACE_CString address; CORBA::UShort port; if (!(cdr.read_string (address) && cdr.read_ushort (port))) { if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) UIPMC_Profile::extract_group_component - Couldn't unmarshal address and port!\n"))); return -1; } TAO_Tagged_Components tagged_components; if (tagged_components.decode (cdr) == 0) return -1; IOP::TaggedComponent tagged_component; tagged_component.tag = IOP::TAG_GROUP; // Try to find it. if (tagged_components.get_component (tagged_component) == 0) return -1; // Found it. const CORBA::Octet *buf = tagged_component.component_data.get_buffer (); TAO_InputCDR in_cdr (reinterpret_cast<const char*> (buf), tagged_component.component_data.length ()); // Extract the Byte Order. if ((in_cdr >> ACE_InputCDR::to_boolean (byte_order)) == 0) return -1; in_cdr.reset_byte_order (static_cast<int> (byte_order)); if ((in_cdr >> group) == 0) return -1; return 0; }

CORBA::ULong TAO_UIPMC_Profile::hash (  CORBA::ULong  max  )  [virtual]

Implements TAO_Profile. Definition at line 419 of file UIPMC_Profile.cpp. References TAO_UIPMC_Endpoint::hash(), TAO_GIOP_Message_Version::minor, and TAO_Profile::tag(). { // Get the hashvalue for all endpoints. CORBA::ULong hashval = this->endpoint_.hash (); hashval += this->version_.minor; hashval += this->tag (); return hashval % max; }

char TAO_UIPMC_Profile::object_key_delimiter (  void   )  const [virtual]

Implements TAO_Profile. Definition at line 31 of file UIPMC_Profile.cpp. References object_key_delimiter_. { return TAO_UIPMC_Profile::object_key_delimiter_; }

void TAO_UIPMC_Profile::parse_string (  const char *  string  )  [virtual]

Reimplemented from TAO_Profile. Definition at line 194 of file UIPMC_Profile.cpp. References ACE_ENV_ARG_PARAMETER, and parse_string_i(). { this->parse_string_i (string ACE_ENV_ARG_PARAMETER); }

void TAO_UIPMC_Profile::parse_string_i (  const char *   )  [protected, virtual]

Implements TAO_Profile. Definition at line 202 of file UIPMC_Profile.cpp. References ACE_CString, ACE_THROW, TAO_UIPMC_Endpoint::object_addr(), set_group_info(), TAO_GIOP_Message_Version::set_version(), ssize_t, ACE_OS::strtoul(), TAO_DEF_MIOP_MAJOR, and TAO_DEF_MIOP_MINOR. Referenced by parse_string(). { // Remove the "N.n@" version prefix, if it exists, and verify the // version is one that we accept. // Check for MIOP version if (isdigit (string [0]) && string[1] == '.' && isdigit (string [2]) && string[3] == '@') { if (string[0] != '1' || string[2] != '0') { ACE_THROW (CORBA::INV_OBJREF ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, EINVAL), CORBA::COMPLETED_NO)); } string += 4; // Skip over the "N.n@" } // UIPMC profiles always use GIOP 1.2 this->version_.set_version (1, 2); // // Parse the group_id. // // Parse the group component version. if (isdigit (string [0]) && string[1] == '.' && isdigit (string [2]) && string[3] == '-') { CORBA::Char major; CORBA::Char minor; major = (char) (string [0] - '0'); minor = (char) (string [2] - '0'); // Verify that a supported version of MIOP is specified. if (major != TAO_DEF_MIOP_MAJOR || minor > TAO_DEF_MIOP_MINOR) { ACE_THROW (CORBA::INV_OBJREF ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, EINVAL), CORBA::COMPLETED_NO)); } // Skip over "N.n-" string += 4; } else { // The group component version is mandatory. ACE_THROW (CORBA::INV_OBJREF ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, EINVAL), CORBA::COMPLETED_NO)); } // Parse the group_domain_id. // The Domain ID is terminated with a '-'. // Wrap the string in a ACE_CString ACE_CString ace_str (string, 0, 0); // Look for the group domain delimitor. ssize_t pos = ace_str.find ('-'); if (pos == ACE_CString::npos) { // The group_domain_id is mandatory, so throw an // exception if it isn't found. ACE_THROW (CORBA::INV_OBJREF ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, EINVAL), CORBA::COMPLETED_NO)); } // Save the group_domain_id. ACE_CString group_domain_id = ace_str.substring (0, pos); // Parse the group_id. // The group_id is terminated with a '-' or a '/'. // Skip past the last '-'. pos++; ssize_t end_pos = ace_str.find ('-',pos); CORBA::Boolean parse_group_ref_version_flag = 0; if (end_pos != ACE_CString::npos) { // String was terminated by a '-', so there's a group // reference version to be parsed. parse_group_ref_version_flag = 1; } else { // Look for a slash as the separator. end_pos = ace_str.find ('/', pos); if (end_pos == ACE_CString::npos) { // The Group ID is mandatory, so throw an exception. ACE_THROW (CORBA::INV_OBJREF ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, EINVAL), CORBA::COMPLETED_NO)); } } // Get the domain_id. ACE_CString str_domain_id = ace_str.substring (pos, end_pos - pos); // Convert the domain_id into numerical form. // @@ group_id is actually 64 bits, but strtoul only can parse 32 bits. // @@ Need a 64 bit strtoul... PortableGroup::ObjectGroupId group_id = ACE_OS::strtoul (str_domain_id.c_str (), 0, 10); PortableGroup::ObjectGroupRefVersion ref_version = 0; if (parse_group_ref_version_flag) { // Try to find the group version. It is terminated by a '/'. pos = end_pos + 1; end_pos = ace_str.find ('/', pos); if (end_pos == ACE_CString::npos) { // The group version was expected but not found, // so throw an exception. ACE_THROW (CORBA::INV_OBJREF ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, EINVAL), CORBA::COMPLETED_NO)); } ACE_CString str_group_ref_ver = ace_str.substring (pos, end_pos - pos); ref_version = ACE_OS::strtoul (str_group_ref_ver.c_str (), 0, 10); } // Parse the group multicast address. // The multicast address is terminated by a ':'. pos = end_pos + 1; end_pos = ace_str.find (':', pos); if (end_pos == ACE_CString::npos) { // The multicast address is mandatory, so throw an exception, // since it wasn't found. ACE_THROW (CORBA::INV_OBJREF ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, EINVAL), CORBA::COMPLETED_NO)); } ACE_CString mcast_addr = ace_str.substring (pos, end_pos - pos); // Parse the multicast port number. // First check that there's something left in the string. pos = end_pos + 1; if (ace_str[pos] == '\0') { // The multicast port is mandatory, so throw an exception, // since it wasn't found. ACE_THROW (CORBA::INV_OBJREF ( CORBA::SystemException::_tao_minor_code ( TAO::VMCID, EINVAL), CORBA::COMPLETED_NO)); } CORBA::UShort mcast_port = static_cast<CORBA::UShort> (ACE_OS::strtoul (ace_str.c_str () + pos, 0, 10)); // // Finally, set all of the fields of the profile. // ACE_INET_Addr addr (mcast_port, mcast_addr.c_str ()); this->endpoint_.object_addr (addr); this->set_group_info (group_domain_id.c_str (), group_id, ref_version); }

const char * TAO_UIPMC_Profile::prefix (  void   )  [static]

Return the char string prefix. Definition at line 477 of file UIPMC_Profile.cpp. { return ::the_prefix; }

void TAO_UIPMC_Profile::request_target_specifier (  TAO_Target_Specification &  target_spec, TAO_Target_Specification::TAO_Target_Address  r )  [virtual]

Definition at line 664 of file UIPMC_Profile.cpp. References ACE_THROW, and TAO_Target_Specification::target_specifier(). { // Fill out the target specifier based on the required type. switch (required_type) { case TAO_Target_Specification::Profile_Addr: // Only using a profile as the target specifier is supported // at this time. Object keys are strictly not supported since // UIPMC profiles do not have object keys. target_spec.target_specifier ( this->create_tagged_profile ()); break; case TAO_Target_Specification::Key_Addr: case TAO_Target_Specification::Reference_Addr: default: // Unsupported or unknown required type. Throw an exception. ACE_THROW (CORBA::MARSHAL ()); } }

void TAO_UIPMC_Profile::set_group_info (  const char *  domain_id, PortableGroup::ObjectGroupId  group_id, PortableGroup::ObjectGroupRefVersion  ref_version )

Add the mandatory group component to this profile. Definition at line 601 of file UIPMC_Profile.cpp. References group_domain_id_, group_id_, ref_version_, and update_cached_group_component(). Referenced by parse_string_i(). { // First, record the group information. this->group_domain_id_.set (domain_id); this->group_id_ = group_id; this->ref_version_ = ref_version; // Update the cached version of the group component. this->update_cached_group_component (); }

int TAO_UIPMC_Profile::supports_multicast (  void   )  const [virtual]

Reimplemented from TAO_Profile. Definition at line 690 of file UIPMC_Profile.cpp. { // Yes! We support multicast! return 1; }

char * TAO_UIPMC_Profile::to_string (   )  [virtual]

Implements TAO_Profile. Definition at line 450 of file UIPMC_Profile.cpp. References TAO_UIPMC_Endpoint::port(), ACE_OS::sprintf(), CORBA::string_alloc(), ACE_OS::strlen(), and the_prefix. { // @@ Frank: Update to pull out GroupID information... size_t buflen = (ACE_OS::strlen (::the_prefix) + 3 /* "loc" */ + 1 /* colon separator */ + 2 /* double-slash separator */ + 1 /* major version */ + 1 /* decimal point */ + 1 /* minor version */ + 1 /* `@' character */ + 15 /* dotted decimal IPv4 address */ + 1 /* colon separator */ + 5 /* port number */); char * buf = CORBA::string_alloc (static_cast<CORBA::ULong> (buflen)); ACE_OS::sprintf (buf, "corbaloc:%s://1.0@%s:%d", ::the_prefix, this->endpoint_.get_host_addr (), this->endpoint_.port ()); return buf; }

void TAO_UIPMC_Profile::update_cached_group_component (  void   )  [protected, virtual]

Definition at line 615 of file UIPMC_Profile.cpp. References ACE_CDR_BYTE_ORDER, ACE_DEBUG, ACE_OutputCDR::begin(), IOP::TaggedComponent::component_data, ACE_Message_Block::cont(), TAO::unbounded_value_sequence< T >::get_buffer(), group_id_, ACE_Message_Block::length(), TAO::unbounded_value_sequence< T >::length(), LM_DEBUG, ACE_OS::memcpy(), ACE_Message_Block::rd_ptr(), ref_version_, TAO_Tagged_Components::set_component(), CORBA::string_dup(), IOP::TaggedComponent::tag, TAO_DEF_MIOP_MAJOR, TAO_DEF_MIOP_MINOR, and ACE_OutputCDR::total_length(). Referenced by set_group_info(). { PortableGroup::TagGroupTaggedComponent group; // Encode the data structure. group.component_version.major = TAO_DEF_MIOP_MAJOR; group.component_version.minor = TAO_DEF_MIOP_MINOR; group.group_domain_id = CORBA::string_dup (this->group_domain_id_.c_str ()); group.object_group_id = this->group_id_; group.object_group_ref_version = this->ref_version_; TAO_OutputCDR out_cdr; // Write the byte order. out_cdr << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER); // Write the group information. if ((out_cdr << group) == 0) { ACE_DEBUG ((LM_DEBUG, "Error marshaling group component!")); return; } size_t length = out_cdr.total_length (); IOP::TaggedComponent tagged_component; tagged_component.tag = IOP::TAG_GROUP; tagged_component.component_data.length (static_cast<CORBA::ULong> (length)); CORBA::Octet *buf = tagged_component.component_data.get_buffer (); for (const ACE_Message_Block *iterator = out_cdr.begin (); iterator != 0; iterator = iterator->cont ()) { size_t i_length = iterator->length (); ACE_OS::memcpy (buf, iterator->rd_ptr (), i_length); buf += i_length; } // Add component with encoded endpoint data to this profile's // TaggedComponents. this->tagged_components_.set_component (tagged_component); }

---

Member Data Documentation

CORBA::ULong TAO_UIPMC_Profile::count_ [protected]

Number of endpoints in the list headed by . Definition at line 144 of file UIPMC_Profile.h.

TAO_UIPMC_Endpoint TAO_UIPMC_Profile::endpoint_ [protected]

Head of this profile's list of endpoints. This endpoint is not dynamically allocated because a profile always contains at least one endpoint. Currently, a profile contains more than one endpoint, i.e., list contains more than just the head, only when RTCORBA is enabled. However, in the near future, this will be used in nonRT mode as well, e.g., to support TAG_ALTERNATE_IIOP_ADDRESS feature. Addressing info of the default endpoint, i.e., head of the list, is transmitted using standard UIPMC ProfileBody components. See method documentation above for how the rest of the endpoint list is transmitted. Definition at line 141 of file UIPMC_Profile.h. Referenced by do_is_equivalent().

ACE_CString TAO_UIPMC_Profile::group_domain_id_ [private]

Group Domain ID. Definition at line 152 of file UIPMC_Profile.h. Referenced by set_group_info().

PortableGroup::ObjectGroupId TAO_UIPMC_Profile::group_id_ [private]

Our group ID within the group domain. Definition at line 155 of file UIPMC_Profile.h. Referenced by set_group_info(), and update_cached_group_component().

TAO_BEGIN_VERSIONED_NAMESPACE_DECL const char TAO_UIPMC_Profile::object_key_delimiter_ = '/' [static]

The object key delimiter that UIPMC uses or expects. Definition at line 28 of file UIPMC_Profile.cpp. Referenced by object_key_delimiter().

PortableGroup::ObjectGroupRefVersion TAO_UIPMC_Profile::ref_version_ [private]

The group reference's version. Definition at line 158 of file UIPMC_Profile.h. Referenced by set_group_info(), and update_cached_group_component().

IOP::TaggedProfile TAO_UIPMC_Profile::tagged_profile_ [private]

Cached version of our tagged profile. Reimplemented from TAO_Profile. Definition at line 149 of file UIPMC_Profile.h.

---

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

• UIPMC_Profile.h
• UIPMC_Profile.cpp

---