ACE_Svc_Handler<, > Class Template Reference

Defines the interface for a service that exchanges data with its connected peer. More...

#include <Svc_Handler.h>

Inheritance diagram for ACE_Svc_Handler<, >:

[legend]Collaboration diagram for ACE_Svc_Handler<, >:

[legend]List of all members.

Public Types
typedef ACE_PEER_STREAM_ADDR	addr_type
typedef ACE_PEER_STREAM	stream_type
Public Member Functions
	ACE_Svc_Handler (ACE_Thread_Manager *thr_mgr=0, ACE_Message_Queue< ACE_SYNCH_USE > *mq=0, ACE_Reactor *reactor=ACE_Reactor::instance())
virtual	~ACE_Svc_Handler (void)
	Destructor.
virtual int	open (void *=0)
virtual int	close (u_long flags=0)
virtual int	idle (u_long flags=0)
virtual ACE_Recyclable_State	recycle_state (void) const
virtual int	recycle_state (ACE_Recyclable_State new_state)
virtual void	cleanup_hint (void **act_holder=0)
virtual int	init (int argc, ACE_TCHAR *argv[])
virtual int	fini (void)
virtual int	info (ACE_TCHAR **info_string, size_t length) const
virtual int	handle_close (ACE_HANDLE=ACE_INVALID_HANDLE, ACE_Reactor_Mask=ACE_Event_Handler::ALL_EVENTS_MASK)
virtual int	handle_timeout (const ACE_Time_Value &time, const void *)
virtual ACE_HANDLE	get_handle (void) const
	Get the underlying handle associated with the .
virtual void	set_handle (ACE_HANDLE)
	Set the underlying handle associated with the .
ACE_PEER_STREAM &	peer (void) const
void *	operator new (size_t n)
void *	operator new (size_t n, void *p)
	This operator permits "placement new" on a per-object basis.
virtual void	destroy (void)
void	operator delete (void *)
void	operator delete (void *, void *)
void	shutdown (void)
	Close down the descriptor and unregister from the Reactor.
void	dump (void) const
	Dump the state of an object.
virtual void	recycler (ACE_Connection_Recycling_Strategy *recycler, const void *recycling_act)
virtual ACE_Connection_Recycling_Strategy *	recycler (void) const
	Get the recycler.
virtual const void *	recycling_act (void) const
	Get the recycling act.
virtual int	recycle (void *=0)
Protected Attributes
ACE_PEER_STREAM	peer_
	Maintain connection with client.
int	dynamic_
	Have we been dynamically created?
int	closing_
ACE_Connection_Recycling_Strategy *	recycler_
	Pointer to the connection recycler.
const void *	recycling_act_

---

Detailed Description

template<ACE_PEER_STREAM_1, ACE_SYNCH_DECL>
class ACE_Svc_Handler<, >

Defines the interface for a service that exchanges data with its connected peer.

This class provides a well-defined interface that the Acceptor and Connector pattern factories use as their target. Typically, client applications will subclass ACE_Svc_Handler and do all the interesting work in the subclass. One thing that the ACE_Svc_Handler does contain is a PEER_STREAM endpoint that is initialized by an ACE_Acceptor or ACE_Connector when a connection is established successfully. This endpoint is used to exchange data between a ACE_Svc_Handler and the peer it is connected with.

Definition at line 51 of file Svc_Handler.h.

---

Member Typedef Documentation

template<ACE_PEER_STREAM_1 , ACE_SYNCH_DECL > typedef ACE_PEER_STREAM_ADDR ACE_Svc_Handler<, >::addr_type

Definition at line 56 of file Svc_Handler.h.

template<ACE_PEER_STREAM_1 , ACE_SYNCH_DECL > typedef ACE_PEER_STREAM ACE_Svc_Handler<, >::stream_type

Definition at line 57 of file Svc_Handler.h.

---

Constructor & Destructor Documentation

template<PR_ST_1 , ACE_SYNCH_DECL > ACE_Svc_Handler<, >::ACE_Svc_Handler (  ACE_Thread_Manager *  thr_mgr = 0, ACE_Message_Queue< ACE_SYNCH_USE > *  mq = 0, ACE_Reactor *  reactor = ACE_Reactor::instance() )

Constructor initializes the thr_mgr and mq by passing them down to the ACE_Task base class. The reactor is passed to the ACE_Event_Handler. Definition at line 136 of file Svc_Handler.cpp. References ACE_SYNCH_USE, ACE_TRACE, ACE_Svc_Handler<, >::dynamic_, ACE_Dynamic::instance(), ACE_Dynamic::is_dynamic(), ACE_Event_Handler::reactor(), and ACE_Dynamic::reset(). : ACE_Task<ACE_SYNCH_USE> (tm, mq), closing_ (0), recycler_ (0), recycling_act_ (0) { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::ACE_Svc_Handler"); this->reactor (reactor); // This clever idiom transparently checks if we were allocated // dynamically. This information is used by the <destroy> method to // decide if we need to delete <this>... The idiom is based on a // paper by Michael van Rooyen (mrooyen@cellnet.co.uk) that appeared // in the April '96 issue of the C++ Report. We've spruced it up to // work correctly in multi-threaded programs by using our ACE_TSS // class. this->dynamic_ = ACE_Dynamic::instance ()->is_dynamic (); if (this->dynamic_ != 0) // Make sure to reset the flag. ACE_Dynamic::instance ()->reset (); }

template<PR_ST_1 , ACE_SYNCH_DECL > ACE_Svc_Handler<, >::~ACE_Svc_Handler (  void   )  [virtual]

Destructor. Definition at line 286 of file Svc_Handler.cpp. References ACE_TRACE, ACE_Svc_Handler<, >::closing_, and ACE_Svc_Handler<, >::shutdown(). { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::~ACE_Svc_Handler"); if (this->closing_ == 0) { // We're closing down now, so make sure not to call ourselves // recursively via other calls to handle_close() (e.g., from the // Timer_Queue). this->closing_ = 1; this->shutdown (); } }

---

Member Function Documentation

template<PR_ST_1 , ACE_SYNCH_DECL > void ACE_Svc_Handler<, >::cleanup_hint (  void **  act_holder = 0  )  [virtual]

When the svc_handle is no longer needed around as a hint, call this method. In addition, reset *act_holder to zero if act_holder != 0. Definition at line 228 of file Svc_Handler.cpp. References ACE_TRACE, ACE_Connection_Recycling_Strategy::cleanup_hint(), and ACE_Svc_Handler<, >::recycler(). { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::cleanup_hint"); // Remove as hint. if (this->recycler ()) this->recycler ()->cleanup_hint (this->recycling_act_, act_holder); }

template<PR_ST_1 , ACE_SYNCH_DECL > int ACE_Svc_Handler<, >::close (  u_long  flags = 0  )  [virtual]

Object termination hook -- application-specific cleanup code goes here. This function is called by the idle() function if the object does not have a ACE_Connection_Recycling_Strategy associated with it. Also, due to this class's derivation from ACE_Task, close() is also called when a thread activated with this object exits. See ACE_Task::close() for further details. The default action of this function is to call handle_close() with the default arguments. Reimplemented from ACE_Task_Base. Definition at line 320 of file Svc_Handler.cpp. References ACE_TRACE, and ACE_Svc_Handler<, >::handle_close(). Referenced by ACE_Svc_Handler<, >::idle(). { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::close"); return this->handle_close (); }

template<PR_ST_1 , ACE_SYNCH_DECL > void ACE_Svc_Handler<, >::destroy (  void   )  [virtual]

Call this to free up dynamically allocated (otherwise you will get memory leaks). In general, you should call this method rather than since this method knows whether or not the object was allocated dynamically, and can act accordingly (i.e., deleting it if it was allocated dynamically). Definition at line 109 of file Svc_Handler.cpp. References ACE_TRACE, ACE_Svc_Handler<, >::closing_, and ACE_Svc_Handler<, >::dynamic_. Referenced by ACE_Svc_Handler<, >::handle_close(). { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::destroy"); // Only delete ourselves if we're not owned by a module and have // been allocated dynamically. if (this->mod_ == 0 && this->dynamic_ && this->closing_ == 0) // Will call the destructor, which automatically calls <shutdown>. // Note that if we are *not* allocated dynamically then the // destructor will call <shutdown> automatically when it gets run // during cleanup. delete this; }

template<PR_ST_1 , ACE_SYNCH_DECL > void ACE_Svc_Handler<, >::dump (  void   )  const

Dump the state of an object. Reimplemented from ACE_Task< ACE_SYNCH_USE >. Reimplemented in ACE_Buffered_Svc_Handler<, >. Definition at line 239 of file Svc_Handler.cpp. References ACE_DEBUG, ACE_TRACE, and LM_DEBUG. { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::dump"); this->peer_.dump (); ACE_DEBUG ((LM_DEBUG, "dynamic_ = %d\n", this->dynamic_)); ACE_DEBUG ((LM_DEBUG, "closing_ = %d\n", this->closing_)); ACE_DEBUG ((LM_DEBUG, "recycler_ = %d\n", this->recycler_)); ACE_DEBUG ((LM_DEBUG, "recycling_act_ = %d\n", this->recycling_act_)); #endif /* ACE_HAS_DUMP */ }

template<PR_ST_1 , ACE_SYNCH_DECL > int ACE_Svc_Handler<, >::fini (  void   )  [virtual]

Default version does no work and returns -1. Must be overloaded by application developer to do anything meaningful. Reimplemented from ACE_Shared_Object. Definition at line 336 of file Svc_Handler.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::fini"); return -1; }

template<PR_ST_1 , ACE_SYNCH_DECL > ACE_HANDLE ACE_Svc_Handler<, >::get_handle (  void   )  const [virtual]

Get the underlying handle associated with the . Reimplemented from ACE_Event_Handler. Definition at line 270 of file Svc_Handler.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::get_handle"); return this->peer_.get_handle (); }

template<PR_ST_1 , ACE_SYNCH_DECL > int ACE_Svc_Handler<, >::handle_close (  ACE_HANDLE  = ACE_INVALID_HANDLE, ACE_Reactor_Mask  = ACE_Event_Handler::ALL_EVENTS_MASK )  [virtual]

Perform termination activities on the SVC_HANDLER. The default behavior is to close down the (to avoid descriptor leaks) and to this object (to avoid memory leaks)! If you don't want this behavior make sure you override this method... Reimplemented from ACE_Event_Handler. Definition at line 302 of file Svc_Handler.cpp. References ACE_Reactor_Mask, ACE_TRACE, and ACE_Svc_Handler<, >::destroy(). Referenced by ACE_Svc_Handler<, >::close(), and ACE_Svc_Handler<, >::handle_timeout(). { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_close"); this->destroy (); return 0; }

template<PR_ST_1 , ACE_SYNCH_DECL > int ACE_Svc_Handler<, >::handle_timeout (  const ACE_Time_Value &  time, const void *  )  [virtual]

Default behavior when timeouts occur is to close down the by calling . Reimplemented from ACE_Event_Handler. Reimplemented in ACE_Buffered_Svc_Handler<, >. Definition at line 312 of file Svc_Handler.cpp. References ACE_TRACE, and ACE_Svc_Handler<, >::handle_close(). { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_timeout"); return this->handle_close (); }

template<PR_ST_1 , ACE_SYNCH_DECL > int ACE_Svc_Handler<, >::idle (  u_long  flags = 0  )  [virtual]

Call this method if you want to recycling the Svc_Handler instead of closing it. If the object does not have a recycler, it will be closed. Definition at line 350 of file Svc_Handler.cpp. References ACE_Connection_Recycling_Strategy::cache(), ACE_Svc_Handler<, >::close(), and ACE_Svc_Handler<, >::recycler(). { if (this->recycler ()) return this->recycler ()->cache (this->recycling_act_); else return this->close (flags); }

template<PR_ST_1 , ACE_SYNCH_DECL > int ACE_Svc_Handler<, >::info (  ACE_TCHAR **  info_string, size_t  length )  const [virtual]

Default version does no work and returns -1. Must be overloaded by application developer to do anything meaningful. Reimplemented from ACE_Shared_Object. Definition at line 343 of file Svc_Handler.cpp. References ACE_TCHAR, and ACE_TRACE. { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::info"); return -1; }

template<PR_ST_1 , ACE_SYNCH_DECL > int ACE_Svc_Handler<, >::init (  int  argc, ACE_TCHAR *  argv[] )  [virtual]

Default version does no work and returns -1. Must be overloaded by application developer to do anything meaningful. Reimplemented from ACE_Shared_Object. Definition at line 327 of file Svc_Handler.cpp. References ACE_TCHAR, and ACE_TRACE. { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::init"); ACE_UNUSED_ARG (argc); ACE_UNUSED_ARG (argv); return -1; }

template<PR_ST_1 , ACE_SYNCH_DECL > int ACE_Svc_Handler<, >::open (  void *  = 0  )  [virtual]

Activate the client handler. This is typically called by the ACE_Acceptor or ACE_Connector. Reimplemented from ACE_Task_Base. Definition at line 166 of file Svc_Handler.cpp. References ACE_DEBUG, ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_PEER_STREAM_ADDR, ACE_TCHAR, ACE_TRACE, LM_DEBUG, LM_ERROR, ACE_Event_Handler::reactor(), and ACE_Reactor::register_handler(). { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::open"); #if defined (ACE_DEBUGGING) ACE_TCHAR buf[BUFSIZ]; ACE_PEER_STREAM_ADDR client_addr; if (this->peer_.get_remote_addr (client_addr) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("get_remote_addr")), -1); else if (client_addr.addr_to_string (buf, sizeof buf) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("can't obtain peer's address")), -1); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("connected to %s on fd %d\n"), buf, this->peer_.get_handle ())); #endif /* ACE_DEBUGGING */ if (this->reactor () && this->reactor ()->register_handler (this, ACE_Event_Handler::READ_MASK) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("unable to register client handler")), -1); return 0; }

template<PR_ST_1 , ACE_SYNCH_DECL > void ACE_Svc_Handler<, >::operator delete (  void *  , void *  )

This operator is necessary to complement the class-specific operator new above. Unfortunately, it's not portable to all C++ compilers... Definition at line 33 of file Svc_Handler.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator delete (NOOP, 2 parameters)"); return; }

template<PR_ST_1 , ACE_SYNCH_DECL > void ACE_Svc_Handler<, >::operator delete (  void *   )

This really should be private so that users are forced to call . Unfortunately, the C++ standard doesn't allow there to be a public new and a private delete. It is a bad idea to call this method directly, so use instead, unless you know for sure that you've allocated the object dynamically. Definition at line 124 of file Svc_Handler.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator delete"); // You cannot delete a 'void*' (X3J16/95-0087 5.3.5.3), but we know // the pointer was created using new char[] (see operator new code), // so we use a cast: ::delete [] static_cast <char *> (obj); }

template<PR_ST_1 , ACE_SYNCH_DECL > ACE_BEGIN_VERSIONED_NAMESPACE_DECL void * ACE_Svc_Handler<, >::operator new (  size_t  n, void *  p )

This operator permits "placement new" on a per-object basis. Definition at line 24 of file Svc_Handler.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator new (NOOP, 2 parameters)"); return p; }

template<PR_ST_1 , ACE_SYNCH_DECL > void * ACE_Svc_Handler<, >::operator new (  size_t  n  )

Overloaded new operator. This method unobtrusively records if a is allocated dynamically, which allows it to clean itself up correctly whether or not it's allocated statically or dynamically. Definition at line 42 of file Svc_Handler.cpp. References ACE_ASSERT, ACE_throw_bad_alloc, ACE_TRACE, ACE_Dynamic::instance(), and ACE_Dynamic::set(). { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator new"); ACE_Dynamic *const dynamic_instance = ACE_Dynamic::instance (); if (dynamic_instance == 0) { // If this ACE_ASSERT fails, it may be due to running of out TSS // keys. Try using ACE_HAS_TSS_EMULATION, or increasing // ACE_DEFAULT_THREAD_KEYS if already using TSS emulation. ACE_ASSERT (dynamic_instance != 0); ACE_throw_bad_alloc; } else { // Allocate the memory and store it (usually in thread-specific // storage, depending on config flags). dynamic_instance->set (); return ::new char[n]; } }

template<PR_ST_1 , ACE_SYNCH_DECL > ACE_PEER_STREAM & ACE_Svc_Handler<, >::peer (  void   )  const

Returns the underlying PEER_STREAM. Used by <ACE_Acceptor::accept> and <ACE_Connector::connect> factories Definition at line 261 of file Svc_Handler.cpp. References ACE_PEER_STREAM, and ACE_TRACE. Referenced by ACE_Svc_Handler<, >::shutdown(). { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::peer"); return (ACE_PEER_STREAM &) this->peer_; }

template<PR_ST_1 , ACE_SYNCH_DECL > int ACE_Svc_Handler<, >::recycle (  void *  = 0  )  [virtual]

Upcall made by the recycler when it is about to recycle the connection. This gives the object a chance to prepare itself for recycling. Return 0 if the object is ready for recycling, -1 on failures. Definition at line 401 of file Svc_Handler.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycle"); // By default, the object is ready and willing to be recycled. return 0; }

template<PR_ST_1 , ACE_SYNCH_DECL > int ACE_Svc_Handler<, >::recycle_state (  ACE_Recyclable_State  new_state  )  [virtual]

Definition at line 359 of file Svc_Handler.cpp. References ACE_Connection_Recycling_Strategy::recycle_state(), and ACE_Svc_Handler<, >::recycler(). { if (this->recycler ()) return this->recycler ()->recycle_state (this->recycling_act_, new_state); return 0; }

template<PR_ST_1 , ACE_SYNCH_DECL > ACE_Recyclable_State ACE_Svc_Handler<, >::recycle_state (  void   )  const [virtual]

Call this method if you want to get/set the state of the Svc_Handler. If the object does not have a recycler, this call will have no effect (and the accessor will return ACE_RECYCLABLE_UNKNOWN). Definition at line 369 of file Svc_Handler.cpp. References ACE_RECYCLABLE_UNKNOWN, ACE_Connection_Recycling_Strategy::recycle_state(), and ACE_Svc_Handler<, >::recycler(). { if (this->recycler ()) return this->recycler ()->recycle_state (this->recycling_act_); return ACE_RECYCLABLE_UNKNOWN; }

template<PR_ST_1 , ACE_SYNCH_DECL > ACE_Connection_Recycling_Strategy * ACE_Svc_Handler<, >::recycler (  void   )  const [virtual]

Get the recycler. Definition at line 387 of file Svc_Handler.cpp. References ACE_TRACE, and ACE_Svc_Handler<, >::recycler_. Referenced by ACE_Svc_Handler<, >::cleanup_hint(), ACE_Svc_Handler<, >::idle(), ACE_Svc_Handler<, >::recycle_state(), and ACE_Svc_Handler<, >::shutdown(). { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycler"); return this->recycler_; }

template<PR_ST_1 , ACE_SYNCH_DECL > void ACE_Svc_Handler<, >::recycler (  ACE_Connection_Recycling_Strategy *  recycler, const void *  recycling_act )  [virtual]

Set the recycler and the that is used during purging and caching. Definition at line 378 of file Svc_Handler.cpp. References ACE_TRACE, ACE_Svc_Handler<, >::recycler_, and ACE_Svc_Handler<, >::recycling_act_. { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycler"); this->recycler_ = recycler; this->recycling_act_ = recycling_act; }

template<PR_ST_1 , ACE_SYNCH_DECL > const void * ACE_Svc_Handler<, >::recycling_act (  void   )  const [virtual]

Get the recycling act. Definition at line 394 of file Svc_Handler.cpp. References ACE_TRACE, and ACE_Svc_Handler<, >::recycling_act_. { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycling_act"); return this->recycling_act_; }

template<PR_ST_1 , ACE_SYNCH_DECL > void ACE_Svc_Handler<, >::set_handle (  ACE_HANDLE   )  [virtual]

Set the underlying handle associated with the . Reimplemented from ACE_Event_Handler. Definition at line 279 of file Svc_Handler.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::set_handle"); this->peer_.set_handle (h); }

template<PR_ST_1 , ACE_SYNCH_DECL > void ACE_Svc_Handler<, >::shutdown (  void   )

Close down the descriptor and unregister from the Reactor. Definition at line 202 of file Svc_Handler.cpp. References ACE_Reactor_Mask, ACE_TRACE, ACE_Reactor::cancel_timer(), ACE_Svc_Handler<, >::peer(), ACE_Connection_Recycling_Strategy::purge(), ACE_Event_Handler::reactor(), ACE_Svc_Handler<, >::recycler(), and ACE_Reactor::remove_handler(). Referenced by ACE_Svc_Handler<, >::~ACE_Svc_Handler(). { ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::shutdown"); // Deregister this handler with the ACE_Reactor. if (this->reactor ()) { ACE_Reactor_Mask mask = ACE_Event_Handler::ALL_EVENTS_MASK | ACE_Event_Handler::DONT_CALL; // Make sure there are no timers. this->reactor ()->cancel_timer (this); if (this->peer ().get_handle () != ACE_INVALID_HANDLE) // Remove self from reactor. this->reactor ()->remove_handler (this, mask); } // Remove self from the recycler. if (this->recycler ()) this->recycler ()->purge (this->recycling_act_); this->peer ().close (); }

---

Member Data Documentation

template<ACE_PEER_STREAM_1 , ACE_SYNCH_DECL > int ACE_Svc_Handler<, >::closing_ [protected]

Keeps track of whether we are in the process of closing (required to avoid circular calls to ). Definition at line 239 of file Svc_Handler.h. Referenced by ACE_Svc_Handler<, >::destroy(), and ACE_Svc_Handler<, >::~ACE_Svc_Handler().

template<ACE_PEER_STREAM_1 , ACE_SYNCH_DECL > int ACE_Svc_Handler<, >::dynamic_ [protected]

Have we been dynamically created? Definition at line 235 of file Svc_Handler.h. Referenced by ACE_Svc_Handler<, >::ACE_Svc_Handler(), and ACE_Svc_Handler<, >::destroy().

template<ACE_PEER_STREAM_1 , ACE_SYNCH_DECL > ACE_PEER_STREAM ACE_Svc_Handler<, >::peer_ [protected]

Maintain connection with client. Definition at line 232 of file Svc_Handler.h.

template<ACE_PEER_STREAM_1 , ACE_SYNCH_DECL > ACE_Connection_Recycling_Strategy* ACE_Svc_Handler<, >::recycler_ [protected]

Pointer to the connection recycler. Definition at line 242 of file Svc_Handler.h. Referenced by ACE_Svc_Handler<, >::recycler().

template<ACE_PEER_STREAM_1 , ACE_SYNCH_DECL > const void* ACE_Svc_Handler<, >::recycling_act_ [protected]

Asynchronous Completion Token (ACT) to be used to when talking to the recycler. Definition at line 246 of file Svc_Handler.h. Referenced by ACE_Svc_Handler<, >::recycler(), and ACE_Svc_Handler<, >::recycling_act().

---

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

• Svc_Handler.h
• Svc_Handler.cpp

---