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<, >:

Inheritance graph
[legend]
Collaboration diagram for ACE_Svc_Handler<, >:

Collaboration graph
[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 <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<, >

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 134 of file Svc_Handler.cpp.

References ACE_TRACE, ACE_Svc_Handler<, >::dynamic_, ACE_Dynamic::instance(), ACE_Dynamic::is_dynamic(), ACE_Event_Handler::reactor(), and ACE_Dynamic::reset().

00137   : ACE_Task<ACE_SYNCH_USE> (tm, mq),
00138     closing_ (false),
00139     recycler_ (0),
00140     recycling_act_ (0)
00141 {
00142   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::ACE_Svc_Handler");
00143 
00144   this->reactor (reactor);
00145 
00146   // This clever idiom transparently checks if we were allocated
00147   // dynamically.  This information is used by the <destroy> method to
00148   // decide if we need to delete <this>...  The idiom is based on a
00149   // paper by Michael van Rooyen (mrooyen@cellnet.co.uk) that appeared
00150   // in the April '96 issue of the C++ Report.  We've spruced it up to
00151   // work correctly in multi-threaded programs by using our ACE_TSS
00152   // class.
00153   this->dynamic_ = ACE_Dynamic::instance ()->is_dynamic ();
00154 
00155   if (this->dynamic_)
00156     // Make sure to reset the flag.
00157     ACE_Dynamic::instance ()->reset ();
00158 }

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

Destructor.

Definition at line 284 of file Svc_Handler.cpp.

References ACE_TRACE, ACE_Svc_Handler<, >::closing_, and ACE_Svc_Handler<, >::shutdown().

00285 {
00286   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::~ACE_Svc_Handler");
00287 
00288   if (this->closing_ == false)
00289     {
00290       // We're closing down now, so make sure not to call ourselves
00291       // recursively via other calls to handle_close() (e.g., from the
00292       // Timer_Queue).
00293       this->closing_ = true;
00294 
00295       this->shutdown ();
00296     }
00297 }

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 226 of file Svc_Handler.cpp.

References ACE_TRACE.

00227 {
00228   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::cleanup_hint");
00229 
00230   // Remove as hint.
00231   if (this->recycler ())
00232     this->recycler ()->cleanup_hint (this->recycling_act_,
00233                                      act_holder);
00234 }

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 319 of file Svc_Handler.cpp.

References ACE_TRACE, and ACE_Svc_Handler<, >::handle_close().

Referenced by ACE_Svc_Handler<, >::idle().

00320 {
00321   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::close");
00322   return this->handle_close ();
00323 }

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

References ACE_TRACE.

Referenced by ACE_Svc_Handler<, >::handle_close().

00108 {
00109   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::destroy");
00110 
00111   // Only delete ourselves if we're not owned by a module and have
00112   // been allocated dynamically.
00113   if (this->mod_ == 0 && this->dynamic_ && this->closing_ == false)
00114     // Will call the destructor, which automatically calls <shutdown>.
00115     // Note that if we are *not* allocated dynamically then the
00116     // destructor will call <shutdown> automatically when it gets run
00117     // during cleanup.
00118     delete this;
00119 }

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 237 of file Svc_Handler.cpp.

References ACE_DEBUG, ACE_TRACE, LM_DEBUG, and ACE_Svc_Handler<, >::peer_.

00238 {
00239 #if defined (ACE_HAS_DUMP)
00240   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::dump");
00241 
00242   this->peer_.dump ();
00243   ACE_DEBUG ((LM_DEBUG,
00244               "dynamic_ = %d\n",
00245               this->dynamic_));
00246   ACE_DEBUG ((LM_DEBUG,
00247               "closing_ = %d\n",
00248               this->closing_));
00249   ACE_DEBUG ((LM_DEBUG,
00250               "recycler_ = %d\n",
00251               this->recycler_));
00252   ACE_DEBUG ((LM_DEBUG,
00253               "recycling_act_ = %d\n",
00254               this->recycling_act_));
00255 #endif /* ACE_HAS_DUMP */
00256 }

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 334 of file Svc_Handler.cpp.

References ACE_TRACE.

00335 {
00336   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::fini");
00337   return -1;
00338 }

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

Get the underlying handle associated with the <peer_>.

Reimplemented from ACE_Event_Handler.

Definition at line 268 of file Svc_Handler.cpp.

References ACE_TRACE, and ACE_Svc_Handler<, >::peer_.

00269 {
00270   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::get_handle");
00271   return this->peer_.get_handle ();
00272 }

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

Reimplemented from ACE_Event_Handler.

Definition at line 300 of file Svc_Handler.cpp.

References ACE_TRACE, and ACE_Svc_Handler<, >::destroy().

Referenced by ACE_Svc_Handler<, >::close(), and ACE_Svc_Handler<, >::handle_timeout().

00302 {
00303   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_close");
00304 
00305   this->destroy ();
00306 
00307   return 0;
00308 }

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 <Svc_Handler> by calling <handle_close>.

Reimplemented from ACE_Event_Handler.

Reimplemented in ACE_Buffered_Svc_Handler<, >.

Definition at line 311 of file Svc_Handler.cpp.

References ACE_TRACE, and ACE_Svc_Handler<, >::handle_close().

00313 {
00314   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_timeout");
00315   return this->handle_close ();
00316 }

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 348 of file Svc_Handler.cpp.

References ACE_Svc_Handler<, >::close().

00349 {
00350   if (this->recycler ())
00351     return this->recycler ()->cache (this->recycling_act_);
00352   else
00353     return this->close (flags);
00354 }

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 341 of file Svc_Handler.cpp.

References ACE_TRACE.

00342 {
00343   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::info");
00344   return -1;
00345 }

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 326 of file Svc_Handler.cpp.

References ACE_TRACE.

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

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 164 of file Svc_Handler.cpp.

References ACE_DEBUG, ACE_ERROR_RETURN, ACE_PEER_STREAM_ADDR, ACE_TEXT, ACE_TRACE, LM_DEBUG, LM_ERROR, ACE_Event_Handler::reactor(), ACE_Event_Handler::READ_MASK, and ACE_Reactor::register_handler().

00165 {
00166   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::open");
00167 #if defined (ACE_DEBUGGING)
00168   ACE_TCHAR buf[BUFSIZ];
00169   ACE_PEER_STREAM_ADDR client_addr;
00170 
00171   if (this->peer_.get_remote_addr (client_addr) == -1)
00172     ACE_ERROR_RETURN ((LM_ERROR,
00173                        ACE_TEXT ("%p\n"),
00174                        ACE_TEXT ("get_remote_addr")),
00175                       -1);
00176   else if (client_addr.addr_to_string (buf, sizeof buf) == -1)
00177     ACE_ERROR_RETURN ((LM_ERROR,
00178                        ACE_TEXT ("%p\n"),
00179                        ACE_TEXT ("can't obtain peer's address")),
00180                       -1);
00181   ACE_DEBUG ((LM_DEBUG,
00182               ACE_TEXT ("connected to %s on fd %d\n"),
00183               buf,
00184               this->peer_.get_handle ()));
00185 #endif /* ACE_DEBUGGING */
00186   if (this->reactor ()
00187       && this->reactor ()->register_handler
00188       (this,
00189        ACE_Event_Handler::READ_MASK) == -1)
00190     ACE_ERROR_RETURN ((LM_ERROR,
00191                        ACE_TEXT ("%p\n"),
00192                        ACE_TEXT ("unable to register client handler")),
00193                       -1);
00194   return 0;
00195 }

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 32 of file Svc_Handler.cpp.

References ACE_TRACE.

00033 {
00034   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator delete (NOOP, 2 parameters)");
00035   return;
00036 }

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

References ACE_TRACE.

00123 {
00124   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator delete");
00125   // You cannot delete a 'void*' (X3J16/95-0087 5.3.5.3), but we know
00126   // the pointer was created using new char[] (see operator new code),
00127   // so we use a cast:
00128   ::delete [] static_cast <char *> (obj);
00129 }

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.

00025 {
00026   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator new (NOOP, 2 parameters)");
00027   return p;
00028 }

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

References ACE_ASSERT, ACE_throw_bad_alloc, ACE_TRACE, ACE_Dynamic::instance(), and ACE_Dynamic::set().

00041 {
00042   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator new");
00043 
00044   ACE_Dynamic *const dynamic_instance = ACE_Dynamic::instance ();
00045 
00046   if (dynamic_instance == 0)
00047     {
00048       // If this ACE_ASSERT fails, it may be due to running of out TSS
00049       // keys.  Try using ACE_HAS_TSS_EMULATION, or increasing
00050       // ACE_DEFAULT_THREAD_KEYS if already using TSS emulation.
00051       ACE_ASSERT (dynamic_instance != 0);
00052 
00053       ACE_throw_bad_alloc;
00054     }
00055   else
00056     {
00057       // Allocate the memory and store it (usually in thread-specific
00058       // storage, depending on config flags).
00059       dynamic_instance->set ();
00060 
00061       return ::new char[n];
00062     }
00063 }

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 259 of file Svc_Handler.cpp.

References ACE_PEER_STREAM, ACE_TRACE, and ACE_Svc_Handler<, >::peer_.

Referenced by ACE_Svc_Handler<, >::shutdown().

00260 {
00261   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::peer");
00262   return (ACE_PEER_STREAM &) this->peer_;
00263 }

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 399 of file Svc_Handler.cpp.

References ACE_TRACE.

00400 {
00401   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycle");
00402   // By default, the object is ready and willing to be recycled.
00403   return 0;
00404 }

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

Definition at line 357 of file Svc_Handler.cpp.

00358 {
00359   if (this->recycler ())
00360     return this->recycler ()->recycle_state (this->recycling_act_,
00361                                              new_state);
00362 
00363   return 0;
00364 }

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 367 of file Svc_Handler.cpp.

References ACE_RECYCLABLE_UNKNOWN.

00368 {
00369   if (this->recycler ())
00370     return this->recycler ()->recycle_state (this->recycling_act_);
00371 
00372   return ACE_RECYCLABLE_UNKNOWN;
00373 }

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

Get the recycler.

Definition at line 385 of file Svc_Handler.cpp.

References ACE_TRACE, and ACE_Svc_Handler<, >::recycler_.

Referenced by ACE_Svc_Handler<, >::recycler().

00386 {
00387   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycler");
00388   return this->recycler_;
00389 }

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 recycling_act that is used during purging and caching.

Definition at line 376 of file Svc_Handler.cpp.

References ACE_TRACE, ACE_Svc_Handler<, >::recycler(), ACE_Svc_Handler<, >::recycler_, and ACE_Svc_Handler<, >::recycling_act_.

00378 {
00379   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycler");
00380   this->recycler_ = recycler;
00381   this->recycling_act_ = recycling_act;
00382 }

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

Get the recycling act.

Definition at line 392 of file Svc_Handler.cpp.

References ACE_TRACE, and ACE_Svc_Handler<, >::recycling_act_.

00393 {
00394   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycling_act");
00395   return this->recycling_act_;
00396 }

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

Set the underlying handle associated with the <peer_>.

Reimplemented from ACE_Event_Handler.

Definition at line 277 of file Svc_Handler.cpp.

References ACE_TRACE, and ACE_Svc_Handler<, >::peer_.

00278 {
00279   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::set_handle");
00280   this->peer_.set_handle (h);
00281 }

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 200 of file Svc_Handler.cpp.

References ACE_TRACE, ACE_Event_Handler::ALL_EVENTS_MASK, ACE_Reactor::cancel_timer(), ACE_Event_Handler::DONT_CALL, ACE_Svc_Handler<, >::peer(), and ACE_Event_Handler::reactor().

Referenced by ACE_Svc_Handler<, >::~ACE_Svc_Handler().

00201 {
00202   ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::shutdown");
00203 
00204   // Deregister this handler with the ACE_Reactor.
00205   if (this->reactor ())
00206     {
00207       ACE_Reactor_Mask mask = ACE_Event_Handler::ALL_EVENTS_MASK |
00208         ACE_Event_Handler::DONT_CALL;
00209 
00210       // Make sure there are no timers.
00211       this->reactor ()->cancel_timer (this);
00212 
00213       if (this->peer ().get_handle () != ACE_INVALID_HANDLE)
00214         // Remove self from reactor.
00215         this->reactor ()->remove_handler (this, mask);
00216     }
00217 
00218   // Remove self from the recycler.
00219   if (this->recycler ())
00220     this->recycler ()->purge (this->recycling_act_);
00221 
00222   this->peer ().close ();
00223 }

Member Data Documentation

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

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

Definition at line 238 of file Svc_Handler.h.

Referenced by ACE_Svc_Handler<, >::~ACE_Svc_Handler().

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

Have we been dynamically created?

Definition at line 234 of file Svc_Handler.h.

Referenced by ACE_Svc_Handler<, >::ACE_Svc_Handler().

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

Maintain connection with client.

Definition at line 231 of file Svc_Handler.h.

Referenced by ACE_Svc_Handler<, >::dump(), ACE_Svc_Handler<, >::get_handle(), ACE_Svc_Handler<, >::peer(), and ACE_Svc_Handler<, >::set_handle().

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 241 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 245 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:
Generated on Tue Feb 2 17:35:43 2010 for ACE by  doxygen 1.4.7