TAO_SHMIOP_Acceptor Class Reference

The SHMIOP-specific bridge class for the concrete acceptor. More...

#include <SHMIOP_Acceptor.h>

Inheritance diagram for TAO_SHMIOP_Acceptor:

[legend]Collaboration diagram for TAO_SHMIOP_Acceptor:

[legend]List of all members.

Public Types
typedef ACE_Strategy_Acceptor< TAO_SHMIOP_Connection_Handler, ACE_MEM_ACCEPTOR >	TAO_SHMIOP_BASE_ACCEPTOR
typedef TAO_Creation_Strategy< TAO_SHMIOP_Connection_Handler >	TAO_SHMIOP_CREATION_STRATEGY
typedef TAO_Concurrency_Strategy< TAO_SHMIOP_Connection_Handler >	TAO_SHMIOP_CONCURRENCY_STRATEGY
typedef TAO_Accept_Strategy< TAO_SHMIOP_Connection_Handler, ACE_MEM_ACCEPTOR >	TAO_SHMIOP_ACCEPT_STRATEGY
Public Member Functions
	TAO_SHMIOP_Acceptor (CORBA::Boolean flag=false)
	Constructor.
	~TAO_SHMIOP_Acceptor (void)
	Destructor.
int	set_mmap_options (const ACE_TCHAR *prefix, off_t size)
The TAO_Acceptor Methods
Please check the documentation in Transport_Acceptor.h for details.
virtual int	open (TAO_ORB_Core *orb_core, ACE_Reactor *reactor, int version_major, int version_minor, const char *port, const char *options=0)
virtual int	open_default (TAO_ORB_Core *orb_core, ACE_Reactor *reactor, int version_major, int version_minor, const char *options=0)
virtual int	close (void)
virtual int	create_profile (const TAO::ObjectKey &object_key, TAO_MProfile &mprofile, CORBA::Short priority)
virtual int	is_collocated (const TAO_Endpoint *endpoint)
virtual CORBA::ULong	endpoint_count (void)
virtual int	object_key (IOP::TaggedProfile &profile, TAO::ObjectKey &key)
Protected Attributes
ACE_CString	host_
ACE_MEM_Addr	address_
	A local endpoint.
TAO_GIOP_Message_Version	version_
	The GIOP version for this endpoint.
TAO_ORB_Core *	orb_core_
	ORB Core.
Private Member Functions
int	open_i (TAO_ORB_Core *orb_core, ACE_Reactor *reactor)
	Implement the common part of the open*() methods.
virtual int	parse_options (const char *options)
	Parse protocol specific options.
int	create_new_profile (const TAO::ObjectKey &object_key, TAO_MProfile &mprofile, CORBA::Short priority)
	Create a SHMIOP profile representing this acceptor.
int	create_shared_profile (const TAO::ObjectKey &object_key, TAO_MProfile &mprofile, CORBA::Short priority)
	Add the endpoints on this acceptor to a shared profile.
Private Attributes
TAO_SHMIOP_BASE_ACCEPTOR	base_acceptor_
	The concrete acceptor, as a pointer to it's base class.
TAO_SHMIOP_CREATION_STRATEGY *	creation_strategy_
	Acceptor strategies.
TAO_SHMIOP_CONCURRENCY_STRATEGY *	concurrency_strategy_
TAO_SHMIOP_ACCEPT_STRATEGY *	accept_strategy_
const ACE_TCHAR *	mmap_file_prefix_
	Determine the prefix (include path name) of the mmap file.
off_t	mmap_size_
CORBA::Boolean	lite_flag_
	Should we use GIOP lite??

---

Detailed Description

The SHMIOP-specific bridge class for the concrete acceptor.

Definition at line 44 of file SHMIOP_Acceptor.h.

---

Member Typedef Documentation

typedef TAO_Accept_Strategy<TAO_SHMIOP_Connection_Handler, ACE_MEM_ACCEPTOR> TAO_SHMIOP_Acceptor::TAO_SHMIOP_ACCEPT_STRATEGY

Definition at line 56 of file SHMIOP_Acceptor.h. Referenced by open_i().

typedef ACE_Strategy_Acceptor<TAO_SHMIOP_Connection_Handler, ACE_MEM_ACCEPTOR> TAO_SHMIOP_Acceptor::TAO_SHMIOP_BASE_ACCEPTOR

Definition at line 53 of file SHMIOP_Acceptor.h.

typedef TAO_Concurrency_Strategy<TAO_SHMIOP_Connection_Handler> TAO_SHMIOP_Acceptor::TAO_SHMIOP_CONCURRENCY_STRATEGY

Definition at line 55 of file SHMIOP_Acceptor.h. Referenced by open_i().

typedef TAO_Creation_Strategy<TAO_SHMIOP_Connection_Handler> TAO_SHMIOP_Acceptor::TAO_SHMIOP_CREATION_STRATEGY

Definition at line 54 of file SHMIOP_Acceptor.h. Referenced by open_i().

---

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_SHMIOP_Acceptor::TAO_SHMIOP_Acceptor (  CORBA::Boolean  flag = false  )

Constructor. Definition at line 24 of file SHMIOP_Acceptor.cpp. References TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR, and TAO_TAG_SHMEM_PROFILE. : TAO_Acceptor (TAO_TAG_SHMEM_PROFILE), version_ (TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR), orb_core_ (0), base_acceptor_ (), creation_strategy_ (0), concurrency_strategy_ (0), accept_strategy_ (0), mmap_file_prefix_ (0), mmap_size_ (1024 * 1024), lite_flag_ (flag) { }

TAO_SHMIOP_Acceptor::~TAO_SHMIOP_Acceptor (  void   )

Destructor. Definition at line 38 of file SHMIOP_Acceptor.cpp. References close(). { // Make sure we are closed before we start destroying the // strategies. this->close (); delete this->creation_strategy_; delete this->concurrency_strategy_; delete this->accept_strategy_; }

---

Member Function Documentation

int TAO_SHMIOP_Acceptor::close (  void   )  [virtual]

Implements TAO_Acceptor. Definition at line 185 of file SHMIOP_Acceptor.cpp. References ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >::close(). Referenced by ~TAO_SHMIOP_Acceptor(). { return this->base_acceptor_.close (); }

int TAO_SHMIOP_Acceptor::create_new_profile (  const TAO::ObjectKey &  object_key, TAO_MProfile &  mprofile, CORBA::Short  priority )  [private]

Create a SHMIOP profile representing this acceptor. Definition at line 72 of file SHMIOP_Acceptor.cpp. References TAO_Profile::_decr_refcnt(), ACE_NEW_RETURN, TAO_ORB_Core::codeset_manager(), TAO_SHMIOP_Profile::endpoint(), ACE_MEM_Addr::get_port_number(), ACE_MEM_Addr::get_remote_addr(), TAO_MProfile::give_profile(), TAO_MProfile::grow(), TAO_GIOP_Message_Version::major, TAO_GIOP_Message_Version::minor, TAO_ORB_Core::orb_params(), TAO_Endpoint::priority(), TAO_MProfile::profile_count(), TAO_Codeset_Manager::set_codeset(), TAO_Tagged_Components::set_orb_type(), TAO_MProfile::size(), TAO_ORB_Parameters::std_profile_components(), TAO_Profile::tagged_components(), and TAO_ORB_TYPE. Referenced by create_profile(), and create_shared_profile(). { // @@ we only make one for now int count = mprofile.profile_count (); if ((mprofile.size () - count) < 1 && mprofile.grow (count + 1) == -1) return -1; TAO_SHMIOP_Profile *pfile = 0; ACE_NEW_RETURN (pfile, TAO_SHMIOP_Profile (this->host_.c_str (), this->address_.get_port_number (), object_key, this->address_.get_remote_addr (), this->version_, this->orb_core_), -1); pfile->endpoint ()->priority (priority); if (mprofile.give_profile (pfile) == -1) { pfile->_decr_refcnt (); pfile = 0; return -1; } // Do not add any tagged components to the profile if configured // by the user not to do so, or if an SHMIOP 1.0 endpoint is being // created (IIOP 1.0 did not support tagged components, so we follow // the same convention for SHMIOP). if (this->orb_core_->orb_params ()->std_profile_components () == 0 || (this->version_.major == 1 && this->version_.minor == 0)) return 0; pfile->tagged_components ().set_orb_type (TAO_ORB_TYPE); TAO_Codeset_Manager *csm = this->orb_core_->codeset_manager(); if (csm) csm->set_codeset(pfile->tagged_components()); return 0; }

int TAO_SHMIOP_Acceptor::create_profile (  const TAO::ObjectKey &  object_key, TAO_MProfile &  mprofile, CORBA::Short  priority )  [virtual]

Implements TAO_Acceptor. Definition at line 55 of file SHMIOP_Acceptor.cpp. References create_new_profile(), create_shared_profile(), and TAO_INVALID_PRIORITY. { // Check if multiple endpoints should be put in one profile or // if they should be spread across multiple profiles. if (priority == TAO_INVALID_PRIORITY) return this->create_new_profile (object_key, mprofile, priority); else return this->create_shared_profile (object_key, mprofile, priority); }

int TAO_SHMIOP_Acceptor::create_shared_profile (  const TAO::ObjectKey &  object_key, TAO_MProfile &  mprofile, CORBA::Short  priority )  [private]

Add the endpoints on this acceptor to a shared profile. Definition at line 116 of file SHMIOP_Acceptor.cpp. References ACE_NEW_RETURN, TAO_SHMIOP_Profile::add_endpoint(), create_new_profile(), ACE_MEM_Addr::get_port_number(), TAO_MProfile::get_profile(), ACE_MEM_Addr::get_remote_addr(), TAO_Endpoint::priority(), TAO_MProfile::profile_count(), TAO_Profile::tag(), TAO_PHandle, and TAO_TAG_SHMEM_PROFILE. Referenced by create_profile(). { TAO_Profile *pfile = 0; TAO_SHMIOP_Profile *shmiop_profile = 0; // First see if <mprofile> already contains a SHMIOP profile. for (TAO_PHandle i = 0; i != mprofile.profile_count (); ++i) { pfile = mprofile.get_profile (i); if (pfile->tag () == TAO_TAG_SHMEM_PROFILE) { shmiop_profile = dynamic_cast <TAO_SHMIOP_Profile *>(pfile); break; } } if (shmiop_profile == 0) { // If <mprofile> doesn't contain SHMIOP_Profile, we need to create // one. return create_new_profile (object_key, mprofile, priority); } else { // A SHMIOP_Profile already exists - just add our endpoint to it. TAO_SHMIOP_Endpoint *endpoint = 0; ACE_NEW_RETURN (endpoint, TAO_SHMIOP_Endpoint (this->host_.c_str (), this->address_.get_port_number (), this->address_.get_remote_addr ()), -1); endpoint->priority (priority); shmiop_profile->add_endpoint (endpoint); return 0; } }

CORBA::ULong TAO_SHMIOP_Acceptor::endpoint_count (  void   )  [virtual]

Implements TAO_Acceptor. Definition at line 411 of file SHMIOP_Acceptor.cpp. { // @@ for now just assume one! // we should take a look at the local address, if it is zero then // get the list of available IP interfaces and return this number. return 1; }

int TAO_SHMIOP_Acceptor::is_collocated (  const TAO_Endpoint *  endpoint  )  [virtual]

Implements TAO_Acceptor. Definition at line 160 of file SHMIOP_Acceptor.cpp. References TAO_SHMIOP_Endpoint::object_addr(), and ACE_MEM_Addr::same_host(). { const TAO_SHMIOP_Endpoint *endp = dynamic_cast <const TAO_SHMIOP_Endpoint *> (endpoint); // Make sure the dynamically cast pointer is valid. if (endp == 0) return 0; // @@ TODO The following code looks funky, why only the host // name is compared? What if there are multiple SHMIOP // servers in the same address? Why do SHMIOP_Endpoints keep // a INET_Addr but not a MEM_Addr? And why is there no lazy // evaluation of IP-addresses for SHMIOP endpoints? Is it // because it is always 'localhost'? We need answers to // these questions to solve: // // http://deuce.doc.wustl.edu/bugzilla/show_bug.cgi?id=1220 // // The following code is suspec // compare the port and sin_addr (numeric host address) return this->address_.same_host (endp->object_addr ()); }

int TAO_SHMIOP_Acceptor::object_key (  IOP::TaggedProfile &  profile, TAO::ObjectKey &  key )  [virtual]

Implements TAO_Acceptor. Definition at line 355 of file SHMIOP_Acceptor.cpp. References ACE_DEBUG, ACE_ERROR, ACE_TEXT, TAO::unbounded_value_sequence< T >::get_buffer(), TAO::unbounded_value_sequence< T >::length(), LM_DEBUG, LM_ERROR, IOP::TaggedProfile::profile_data, ACE_InputCDR::read_octet(), ACE_InputCDR::read_string(), ACE_InputCDR::read_ushort(), and TAO_debug_level. { // 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<char*>(profile.profile_data.get_buffer ()), profile.profile_data.length ()); #endif /* TAO_NO_COPY_OCTET_SEQUENCES == 1 */ CORBA::Octet major = 0; CORBA::Octet minor = 0; // 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) - SHMIOP_Profile::decode, v%d.%d\n"), major, minor)); } return -1; } CORBA::String_var host; CORBA::UShort port = 0; // Get host and port. No processing here too.. if (cdr.read_string (host.out ()) == 0 || cdr.read_ushort (port) == 0) { if (TAO_debug_level > 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) - SHMIOP_Acceptor::object_key, ") ACE_TEXT ("error while decoding host/port\n"))); } return -1; } // ... and object key. if ((cdr >> object_key) == 0) return -1; // We are NOT bothered about the rest. return 1; }

int TAO_SHMIOP_Acceptor::open (  TAO_ORB_Core *  orb_core, ACE_Reactor *  reactor, int  version_major, int  version_minor, const char *  port, const char *  options = 0 )  [virtual]

Implements TAO_Acceptor. Definition at line 191 of file SHMIOP_Acceptor.cpp. References ACE_TEXT_CHAR_TO_TCHAR, open_i(), parse_options(), ACE_MEM_Addr::set(), and TAO_GIOP_Message_Version::set_version(). { if (major >=0 && minor >= 0) this->version_.set_version (static_cast <CORBA::Octet>(major), static_cast <CORBA::Octet>(minor)); // Parse options if (this->parse_options (options) == -1) return -1; if (isdigit (*port) == 0) return -1; // Port number must consist of digits if (port) this->address_.set (ACE_TEXT_CHAR_TO_TCHAR(port)); return this->open_i (orb_core, reactor); }

int TAO_SHMIOP_Acceptor::open_default (  TAO_ORB_Core *  orb_core, ACE_Reactor *  reactor, int  version_major, int  version_minor, const char *  options = 0 )  [virtual]

Implements TAO_Acceptor. Definition at line 216 of file SHMIOP_Acceptor.cpp. References ACE_MEM_Addr::get_host_name(), open_i(), parse_options(), and TAO_GIOP_Message_Version::set_version(). { if (major >=0 && minor >= 0) this->version_.set_version (static_cast <CORBA::Octet>(major), static_cast <CORBA::Octet>(minor)); // Parse options if (this->parse_options (options) == -1) return -1; // @@ Until we can support multihomed machines correctly we must // pick the "default interface" and only listen on that IP // address. this->host_ = this->address_.get_host_name (); return this->open_i (orb_core, reactor); }

int TAO_SHMIOP_Acceptor::open_i (  TAO_ORB_Core *  orb_core, ACE_Reactor *  reactor )  [private]

Implement the common part of the open*() methods. Definition at line 250 of file SHMIOP_Acceptor.cpp. References ACE_Strategy_Acceptor< SVC_HANDLER, >::acceptor(), ACE_CLOEXEC, ACE_DEBUG, ACE_ERROR, ACE_NEW_RETURN, ACE_TCHAR, ACE_TEXT, ACE_TEXT_ALWAYS_CHAR, ACE_TEXT_CHAR_TO_TCHAR, ACE_INET_Addr::get_host_addr(), ACE_MEM_Addr::get_host_name(), ACE_MEM_Addr::get_port_number(), ACE_MEM_Addr::get_remote_addr(), LM_DEBUG, LM_ERROR, MAXHOSTNAMELEN, ACE_Strategy_Acceptor< SVC_HANDLER, >::open(), TAO_debug_level, TAO_SHMIOP_ACCEPT_STRATEGY, TAO_SHMIOP_CONCURRENCY_STRATEGY, and TAO_SHMIOP_CREATION_STRATEGY. Referenced by open(), and open_default(). { this->orb_core_ = orb_core; ACE_NEW_RETURN (this->creation_strategy_, TAO_SHMIOP_CREATION_STRATEGY (this->orb_core_, this->lite_flag_), -1); ACE_NEW_RETURN (this->concurrency_strategy_, TAO_SHMIOP_CONCURRENCY_STRATEGY (this->orb_core_), -1); ACE_NEW_RETURN (this->accept_strategy_, TAO_SHMIOP_ACCEPT_STRATEGY (this->orb_core_), -1); // We only accept connection on localhost. if (this->base_acceptor_.open (this->address_, reactor, this->creation_strategy_, this->accept_strategy_, this->concurrency_strategy_) == -1) { if (TAO_debug_level > 0) ACE_ERROR ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) - SHMIOP_Acceptor::open_i, %p\n\n"), ACE_TEXT ("cannot open acceptor"))); return -1; } this->base_acceptor_.acceptor().mmap_prefix (this->mmap_file_prefix_); this->base_acceptor_.acceptor().init_buffer_size (this->mmap_size_); if (orb_core->server_factory ()->activate_server_connections () != 0) this->base_acceptor_.acceptor().preferred_strategy (ACE_MEM_IO::MT); // @@ Should this be a catastrophic error??? if (this->base_acceptor_.acceptor ().get_local_addr (this->address_) != 0) { if (TAO_debug_level > 0) ACE_ERROR ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) - SHMIOP_Acceptor::open_i, %p\n\n"), ACE_TEXT ("cannot get local addr\n"))); return -1; } // If the ORB is instructed to use dotted decimal addresses, we respect that // also for shmiop if (orb_core->orb_params ()->use_dotted_decimal_addresses ()) { // Get the ip address, we get the remote addr to put in the IOR, don't // calls get_host_addr() directly on address_, we then get the internal // address back const char *tmp = this->address_.get_remote_addr().get_host_addr (); if (tmp == 0) { if (TAO_debug_level > 0) ACE_ERROR ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) - ") ACE_TEXT ("SHMIOP_Acceptor::open_i, ") ACE_TEXT ("- %p, "), ACE_TEXT ("cannot determine hostname\n"))); return -1; } this->host_ = tmp; } else { // This will be the actualy host name of the original endpoint. ACE_TCHAR tmp_host[MAXHOSTNAMELEN+1]; if (this->address_.get_host_name (tmp_host, sizeof tmp_host) != 0) { if (TAO_debug_level > 0) ACE_ERROR ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) - SHMIOP_Acceptor::open_i, - %p\n"), ACE_TEXT ("cannot cache hostname\n"))); return -1; } this->host_ = ACE_TEXT_ALWAYS_CHAR(tmp_host); } // This avoids having child processes acquire the listen socket thereby // denying the server the opportunity to restart on a well-known endpoint. // This does not affect the aberrent behavior on Win32 platforms. (void) this->base_acceptor_.acceptor().enable (ACE_CLOEXEC); if (TAO_debug_level > 5) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - SHMIOP_Acceptor::open_i, ") ACE_TEXT ("listening on : <%s:%u>\n"), ACE_TEXT_CHAR_TO_TCHAR(this->host_.c_str ()), this->address_.get_port_number ())); } return 0; }

int TAO_SHMIOP_Acceptor::parse_options (  const char *  options  )  [private, virtual]

Parse protocol specific options. Definition at line 420 of file SHMIOP_Acceptor.cpp. References ACE_CString, ACE_ERROR_RETURN, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, and LM_ERROR. Referenced by open(), and open_default(). { if (str == 0) return 0; // No options to parse. Not a problem. // Use an option format similar to the one used for CGI scripts in // HTTP URLs. // e.g.: option1=foo&option2=bar ACE_CString options (str); size_t len = options.length (); const char option_delimiter = '&'; // Count the number of options. CORBA::ULong option_count = 1; // Number of endpoints in the string (initialized to 1). // Only check for endpoints after the protocol specification and // before the object key. for (size_t i = 0; i < len; ++i) if (options[i] == option_delimiter) option_count++; // The idea behind the following loop is to split the options into // (option, name) pairs. // For example, // `option1=foo&option2=bar' // will be parsed into: // `option1=foo' // `option2=bar' int begin = 0; int end = -1; for (CORBA::ULong j = 0; j < option_count; ++j) { begin += end + 1; if (j < option_count - 1) end = options.find (option_delimiter, begin); else end = static_cast <int>(len - begin); // Handle last endpoint differently if (end == begin) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) Zero length SHMIOP option.\n")), -1); else if (end != ACE_CString::npos) { ACE_CString opt = options.substring (begin, end); int slot = opt.find ("="); if (slot == static_cast <int> (len - 1) || slot == ACE_CString::npos) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) SHMIOP option <%s> is ") ACE_TEXT ("missing a value.\n"), ACE_TEXT_CHAR_TO_TCHAR(opt.c_str ())), -1); ACE_CString name = opt.substring (0, slot); ACE_CString value = opt.substring (slot + 1); if (name.length () == 0) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) Zero length SHMIOP ") ACE_TEXT ("option name.\n")), -1); if (name == "priority") { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) Invalid SHMIOP endpoint format: ") ACE_TEXT ("endpoint priorities no longer supported.\n")), -1); } else ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) Invalid SHMIOP option: <%s>\n"), ACE_TEXT_CHAR_TO_TCHAR(name.c_str ())), -1); } } return 0; }

int TAO_SHMIOP_Acceptor::set_mmap_options (  const ACE_TCHAR *  prefix, off_t  size )

Set the MMAP options the MEM_Stream this acceptor creates will use. Definition at line 240 of file SHMIOP_Acceptor.cpp. References mmap_file_prefix_, and mmap_size_. Referenced by TAO_SHMIOP_Protocol_Factory::make_acceptor(). { this->mmap_file_prefix_ = prefix; this->mmap_size_ = size; return 0; }

---

Member Data Documentation

TAO_SHMIOP_ACCEPT_STRATEGY* TAO_SHMIOP_Acceptor::accept_strategy_ [private]

Definition at line 135 of file SHMIOP_Acceptor.h.

ACE_MEM_Addr TAO_SHMIOP_Acceptor::address_ [protected]

A local endpoint. Definition at line 120 of file SHMIOP_Acceptor.h.

TAO_SHMIOP_BASE_ACCEPTOR TAO_SHMIOP_Acceptor::base_acceptor_ [private]

The concrete acceptor, as a pointer to it's base class. Definition at line 130 of file SHMIOP_Acceptor.h.

TAO_SHMIOP_CONCURRENCY_STRATEGY* TAO_SHMIOP_Acceptor::concurrency_strategy_ [private]

Definition at line 134 of file SHMIOP_Acceptor.h.

TAO_SHMIOP_CREATION_STRATEGY* TAO_SHMIOP_Acceptor::creation_strategy_ [private]

Acceptor strategies. Definition at line 133 of file SHMIOP_Acceptor.h.

ACE_CString TAO_SHMIOP_Acceptor::host_ [protected]

Cache the information about the endpoint serviced by this acceptor. Todo: There may in fact be multiple hostnames for this endpoint. For example it the IP address is INADDR_ANY (0.0.0.0) then there will be possibly a different hostname for each interface. Definition at line 117 of file SHMIOP_Acceptor.h.

CORBA::Boolean TAO_SHMIOP_Acceptor::lite_flag_ [private]

Should we use GIOP lite?? Definition at line 145 of file SHMIOP_Acceptor.h.

const ACE_TCHAR* TAO_SHMIOP_Acceptor::mmap_file_prefix_ [private]

Determine the prefix (include path name) of the mmap file. Definition at line 138 of file SHMIOP_Acceptor.h. Referenced by set_mmap_options().

off_t TAO_SHMIOP_Acceptor::mmap_size_ [private]

Determine the minimum size of mmap file. This dictate the maximum size of a CORBA method invocation. Definition at line 142 of file SHMIOP_Acceptor.h. Referenced by set_mmap_options().

TAO_ORB_Core* TAO_SHMIOP_Acceptor::orb_core_ [protected]

ORB Core. Definition at line 126 of file SHMIOP_Acceptor.h.

TAO_GIOP_Message_Version TAO_SHMIOP_Acceptor::version_ [protected]

The GIOP version for this endpoint. Definition at line 123 of file SHMIOP_Acceptor.h.

---

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

• SHMIOP_Acceptor.h
• SHMIOP_Acceptor.cpp

---