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

#include <Svc_Handler.h>

Inheritance diagram for ACE_Svc_Handler< ACE_PEER_STREAM_1, ACE_SYNCH_DECL >:

Collaboration diagram for ACE_Svc_Handler< ACE_PEER_STREAM_1, ACE_SYNCH_DECL >:

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 <peer_>.
virtual void	set_handle (ACE_HANDLE)
	Set the underlying handle associated with the <peer_>.
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.
bool	dynamic_
	Have we been dynamically created?
bool	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< ACE_PEER_STREAM_1, ACE_SYNCH_DECL >

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 57 of file Svc_Handler.h.

Member Typedef Documentation

template<ACE_PEER_STREAM_1 , ACE_SYNCH_DECL >

typedef ACE_PEER_STREAM_ADDR ACE_Svc_Handler< ACE_PEER_STREAM_1, ACE_SYNCH_DECL >::addr_type

Definition at line 62 of file Svc_Handler.h.

template<ACE_PEER_STREAM_1 , ACE_SYNCH_DECL >

typedef ACE_PEER_STREAM ACE_Svc_Handler< ACE_PEER_STREAM_1, ACE_SYNCH_DECL >::stream_type

Definition at line 63 of file Svc_Handler.h.

Constructor & Destructor Documentation

template<PR_ST_1 , ACE_SYNCH_DECL >

ACE_Svc_Handler< PR_ST_1, ACE_SYNCH_DECL >::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 134 of file Svc_Handler.cpp.

  : ACE_Task<ACE_SYNCH_USE> (tm, mq),
    closing_ (false),
    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_)
    // Make sure to reset the flag.
    ACE_Dynamic::instance ()->reset ();
}

template<PR_ST_1 , ACE_SYNCH_DECL >

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

Destructor.

Definition at line 284 of file Svc_Handler.cpp.

{
  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::~ACE_Svc_Handler");

  if (this->closing_ == false)
    {
      // 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_ = true;

      this->shutdown ();
    }
}

Member Function Documentation

template<PR_ST_1 , ACE_SYNCH_DECL >

void ACE_Svc_Handler< PR_ST_1, ACE_SYNCH_DECL >::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 226 of file Svc_Handler.cpp.

{
  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< PR_ST_1, ACE_SYNCH_DECL >::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 323 of file Svc_Handler.cpp.

{
  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< PR_ST_1, ACE_SYNCH_DECL >::destroy ( void ) [virtual]

Call this to free up dynamically allocated <Svc_Handlers> (otherwise you will get memory leaks). In general, you should call this method rather than <delete> 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 107 of file Svc_Handler.cpp.

{
  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_ == false)
    // 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< PR_ST_1, ACE_SYNCH_DECL >::dump ( void ) const

Dump the state of an object.

Reimplemented from ACE_Task< ACE_SYNCH_USE >.

Reimplemented in ACE_Buffered_Svc_Handler< ACE_PEER_STREAM_1, ACE_SYNCH_DECL >.

Definition at line 237 of file Svc_Handler.cpp.

{
#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< PR_ST_1, ACE_SYNCH_DECL >::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 338 of file Svc_Handler.cpp.

{
  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< PR_ST_1, ACE_SYNCH_DECL >::get_handle ( void ) const [virtual]

Get the underlying handle associated with the <peer_>.

Definition at line 268 of file Svc_Handler.cpp.

{
  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< PR_ST_1, ACE_SYNCH_DECL >::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 <peer_> (to avoid descriptor leaks) and to <destroy> this object (to avoid memory leaks)! If you don't want this behavior make sure you override this method...

Definition at line 300 of file Svc_Handler.cpp.

{
  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_close");

  if (this->reference_counting_policy ().value () ==
      ACE_Event_Handler::Reference_Counting_Policy::DISABLED)
    {
      this->destroy ();
    }

  return 0;
}

template<PR_ST_1 , ACE_SYNCH_DECL >

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

Default behavior when timeouts occur is to close down the <Svc_Handler> by calling <handle_close>.

Reimplemented in ACE_Buffered_Svc_Handler< ACE_PEER_STREAM_1, ACE_SYNCH_DECL >.

Definition at line 315 of file Svc_Handler.cpp.

{
  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< PR_ST_1, ACE_SYNCH_DECL >::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 352 of file Svc_Handler.cpp.

{
  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< PR_ST_1, ACE_SYNCH_DECL >::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 345 of file Svc_Handler.cpp.

{
  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< PR_ST_1, ACE_SYNCH_DECL >::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 330 of file Svc_Handler.cpp.

{
  ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::init");
  return -1;
}

template<PR_ST_1 , ACE_SYNCH_DECL >

int ACE_Svc_Handler< PR_ST_1, ACE_SYNCH_DECL >::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 164 of file Svc_Handler.cpp.

{
  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_TEXT ("%p\n"),
                       ACE_TEXT ("get_remote_addr")),
                      -1);
  else if (client_addr.addr_to_string (buf, sizeof buf) == -1)
    ACE_ERROR_RETURN ((LM_ERROR,
                       ACE_TEXT ("%p\n"),
                       ACE_TEXT ("can't obtain peer's address")),
                      -1);
  ACE_DEBUG ((LM_DEBUG,
              ACE_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_TEXT ("%p\n"),
                       ACE_TEXT ("unable to register client handler")),
                      -1);
  return 0;
}

template<PR_ST_1 , ACE_SYNCH_DECL >

void ACE_Svc_Handler< PR_ST_1, ACE_SYNCH_DECL >::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 32 of file Svc_Handler.cpp.

{
  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< PR_ST_1, ACE_SYNCH_DECL >::operator delete ( void * obj )

This really should be private so that users are forced to call <destroy>. 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 <destroy> instead, unless you know for sure that you've allocated the object dynamically.

Definition at line 122 of file Svc_Handler.cpp.

{
  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 >

void * ACE_Svc_Handler< PR_ST_1, ACE_SYNCH_DECL >::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.

{
  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< PR_ST_1, ACE_SYNCH_DECL >::operator new ( size_t n )

Overloaded new operator. This method unobtrusively records if a <Svc_Handler> is allocated dynamically, which allows it to clean itself up correctly whether or not it's allocated statically or dynamically.

Definition at line 40 of file Svc_Handler.cpp.

{
  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< PR_ST_1, ACE_SYNCH_DECL >::peer ( void ) const

Returns the underlying PEER_STREAM. Used by <ACE_Acceptor::accept> and <ACE_Connector::connect> factories

Definition at line 259 of file Svc_Handler.cpp.

{
  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< PR_ST_1, ACE_SYNCH_DECL >::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 403 of file Svc_Handler.cpp.

{
  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 >

ACE_Recyclable_State ACE_Svc_Handler< PR_ST_1, ACE_SYNCH_DECL >::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 371 of file Svc_Handler.cpp.

{
  if (this->recycler ())
    return this->recycler ()->recycle_state (this->recycling_act_);

  return ACE_RECYCLABLE_UNKNOWN;
}

template<PR_ST_1 , ACE_SYNCH_DECL >

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

Definition at line 361 of file Svc_Handler.cpp.

{
  if (this->recycler ())
    return this->recycler ()->recycle_state (this->recycling_act_,
                                             new_state);

  return 0;
}

template<PR_ST_1 , ACE_SYNCH_DECL >

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

Get the recycler.

Definition at line 389 of file Svc_Handler.cpp.

{
  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< PR_ST_1, ACE_SYNCH_DECL >::recycler	(	ACE_Connection_Recycling_Strategy *	recycler,
		const void *	recycling_act
	)			`[virtual]`

Set the recycler and the recycling_act that is used during purging and caching.

Definition at line 380 of file Svc_Handler.cpp.

{
  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< PR_ST_1, ACE_SYNCH_DECL >::recycling_act ( void ) const [virtual]

Get the recycling act.

Definition at line 396 of file Svc_Handler.cpp.

{
  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< PR_ST_1, ACE_SYNCH_DECL >::set_handle ( ACE_HANDLE h ) [virtual]

Set the underlying handle associated with the <peer_>.

Definition at line 277 of file Svc_Handler.cpp.

{
  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< PR_ST_1, ACE_SYNCH_DECL >::shutdown ( void )

Close down the descriptor and unregister from the Reactor.

Definition at line 200 of file Svc_Handler.cpp.

{
  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 >

bool ACE_Svc_Handler< ACE_PEER_STREAM_1, ACE_SYNCH_DECL >::closing_ [protected]

Keeps track of whether we are in the process of closing (required to avoid circular calls to <handle_close>).

Definition at line 244 of file Svc_Handler.h.

template<ACE_PEER_STREAM_1 , ACE_SYNCH_DECL >

bool ACE_Svc_Handler< ACE_PEER_STREAM_1, ACE_SYNCH_DECL >::dynamic_ [protected]

Have we been dynamically created?

Definition at line 240 of file Svc_Handler.h.

template<ACE_PEER_STREAM_1 , ACE_SYNCH_DECL >

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

Maintain connection with client.

Definition at line 237 of file Svc_Handler.h.

template<ACE_PEER_STREAM_1 , ACE_SYNCH_DECL >

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

Pointer to the connection recycler.

Definition at line 247 of file Svc_Handler.h.

template<ACE_PEER_STREAM_1 , ACE_SYNCH_DECL >

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

Asynchronous Completion Token (ACT) to be used to when talking to the recycler.

Definition at line 251 of file Svc_Handler.h.

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

ACE_Svc_Handler< ACE_PEER_STREAM_1, ACE_SYNCH_DECL > Class Template Reference

Public Types

Public Member Functions

Protected Attributes

Detailed Description

template<ACE_PEER_STREAM_1, ACE_SYNCH_DECL> class ACE_Svc_Handler< ACE_PEER_STREAM_1, ACE_SYNCH_DECL >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<ACE_PEER_STREAM_1, ACE_SYNCH_DECL>
class ACE_Svc_Handler< ACE_PEER_STREAM_1, ACE_SYNCH_DECL >