*Backed out changeset 3be01fb200a5

--HG--
branch : trunk

dep/ACE_wrappers/ace/Svc_Handler.h

@@ -1,4 +1,5 @@
 // -*- C++ -*-
+
 //=============================================================================
 /**
  *  @file   Svc_Handler.h
@@ -9,24 +10,33 @@
  *  @author Irfan Pyarali <[email protected]>
  */
 //=============================================================================
+
 #ifndef ACE_SVC_HANDLER_H
 #define ACE_SVC_HANDLER_H
+
 #include /**/ "ace/pre.h"
+
 #include "ace/Synch_Options.h"
+
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
+
 #include "ace/Task.h"
 #include "ace/Recyclable.h"
 #include "ace/Reactor.h"
+
 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
+
 // Forward decls.
 class ACE_Connection_Recycling_Strategy;
+
 // This enum is used as the flags parameter when calling the close()
 // method on the ACE_Svc_Handler.
 enum ACE_Svc_Handler_Close { NORMAL_CLOSE_OPERATION = 0x00,
                              CLOSE_DURING_NEW_CONNECTION = 0x01
                            };
+
 /**
  * @class ACE_Svc_Handler
  *
@@ -47,9 +57,11 @@ template <ACE_PEER_STREAM_1, ACE_SYNCH_DECL>
 class ACE_Svc_Handler : public ACE_Task<ACE_SYNCH_USE>
 {
 public:
+
   // Useful STL-style traits.
   typedef ACE_PEER_STREAM_ADDR addr_type;
   typedef ACE_PEER_STREAM      stream_type;
+
   /**
    * Constructor initializes the @a thr_mgr and @a mq by passing them
    * down to the ACE_Task base class.  The @a reactor is passed to
@@ -58,11 +70,14 @@ public:
   ACE_Svc_Handler (ACE_Thread_Manager *thr_mgr = 0,
                    ACE_Message_Queue<ACE_SYNCH_USE> *mq = 0,
                    ACE_Reactor *reactor = ACE_Reactor::instance ());
+
   /// Destructor.
   virtual ~ACE_Svc_Handler (void);
+
   /// Activate the client handler.  This is typically called by the
   /// ACE_Acceptor or ACE_Connector.
   virtual int open (void * = 0);
+
   /**
    * Object termination hook -- application-specific cleanup code goes
    * here. This function is called by the idle() function if the object
@@ -73,12 +88,14 @@ public:
    * function is to call handle_close() with the default arguments.
    */
   virtual int close (u_long flags = 0);
+
   /**
    * Call this method if you want to recycling the @c Svc_Handler
    * instead of closing it. If the object does not have a recycler,
    * it will be closed.
    */
   virtual int idle (u_long flags = 0);
+
   /**
    * Call this method if you want to get/set the state of the
    * @c Svc_Handler.  If the object does not have a recycler, this call
@@ -87,23 +104,29 @@ public:
    */
   virtual ACE_Recyclable_State recycle_state (void) const;
   virtual int recycle_state (ACE_Recyclable_State new_state);
+
   /**
    * When the svc_handle is no longer needed around as a hint, call
    * this method. In addition, reset @c *act_holder to zero if
    * @a act_holder != 0.
    */
   virtual void cleanup_hint (void **act_holder = 0);
+
   // = Dynamic linking hooks.
   /// Default version does no work and returns -1.  Must be overloaded
   /// by application developer to do anything meaningful.
   virtual int init (int argc, ACE_TCHAR *argv[]);
+
   /// Default version does no work and returns -1.  Must be overloaded
   /// by application developer to do anything meaningful.
   virtual int fini (void);
+
   /// Default version does no work and returns -1.  Must be overloaded
   /// by application developer to do anything meaningful.
   virtual int info (ACE_TCHAR **info_string, size_t length) const;
+
   // = Demultiplexing hooks.
+
   /**
    * Perform termination activities on the SVC_HANDLER.  The default
    * behavior is to close down the <peer_> (to avoid descriptor leaks)
@@ -112,22 +135,28 @@ public:
    */
   virtual int handle_close (ACE_HANDLE = ACE_INVALID_HANDLE,
                             ACE_Reactor_Mask = ACE_Event_Handler::ALL_EVENTS_MASK);
+
   /// Default behavior when timeouts occur is to close down the
   /// <Svc_Handler> by calling <handle_close>.
   virtual int handle_timeout (const ACE_Time_Value &time,
                               const void *);
+
   /// Get the underlying handle associated with the <peer_>.
   virtual ACE_HANDLE get_handle (void) const;
+
   /// Set the underlying handle associated with the <peer_>.
   virtual void set_handle (ACE_HANDLE);
+
   /// Returns the underlying PEER_STREAM.  Used by
   /// <ACE_Acceptor::accept> and <ACE_Connector::connect> factories
   ACE_PEER_STREAM &peer (void) const;
+
   /// 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.
   void *operator new (size_t n);
+
 #if defined (ACE_HAS_NEW_NOTHROW)
   /// Overloaded new operator, nothrow_t variant. Unobtrusively records if a
   /// <Svc_Handler> is allocated dynamically, which allows it to clean
@@ -138,8 +167,10 @@ public:
   void operator delete (void *p, const ACE_nothrow_t&) throw ();
 #endif /* ACE_LACKS_PLACEMENT_OPERATOR_DELETE */
 #endif
+
   /// This operator permits "placement new" on a per-object basis.
   void * operator new (size_t n, void *p);
+
   /**
    * Call this to free up dynamically allocated <Svc_Handlers>
    * (otherwise you will get memory leaks).  In general, you should
@@ -148,6 +179,7 @@ public:
    * accordingly (i.e., deleting it if it was allocated dynamically).
    */
   virtual void destroy (void);
+
   /**
    * This really should be private so that users are forced to call
    * <destroy>.  Unfortunately, the C++ standard doesn't allow there
@@ -156,6 +188,7 @@ public:
    * know for sure that you've allocated the object dynamically.
    */
   void operator delete (void *);
+
 #if !defined (ACE_LACKS_PLACEMENT_OPERATOR_DELETE)
   /**
    * This operator is necessary to complement the class-specific
@@ -164,23 +197,33 @@ public:
    */
   void operator delete (void *, void *);
 #endif /* ACE_LACKS_PLACEMENT_OPERATOR_DELETE */
+
   /// Close down the descriptor and unregister from the Reactor
   void shutdown (void);
+
   /// Dump the state of an object.
   void dump (void) const;
+
 public:
+
   // = The following methods are not suppose to be public.
+
   // Because friendship is *not* inherited in C++, these methods have
   // to be public.
+
   // = Accessors to set/get the connection recycler.
+
   /// Set the recycler and the @a recycling_act that is used during
   /// purging and caching.
   virtual void recycler (ACE_Connection_Recycling_Strategy *recycler,
                          const void *recycling_act);
+
   /// Get the recycler.
   virtual ACE_Connection_Recycling_Strategy *recycler (void) const;
+
   /// Get the recycling act.
   virtual const void *recycling_act (void) const;
+
   /**
    * Upcall made by the recycler when it is about to recycle the
    * connection.  This gives the object a chance to prepare itself for
@@ -188,20 +231,26 @@ public:
    * failures.
    */
   virtual int recycle (void * = 0);
+
 protected:
   /// Maintain connection with client.
   ACE_PEER_STREAM peer_;
+
   /// Have we been dynamically created?
   bool dynamic_;
+
   /// Keeps track of whether we are in the process of closing (required
   /// to avoid circular calls to <handle_close>).
   bool closing_;
+
   /// Pointer to the connection recycler.
   ACE_Connection_Recycling_Strategy *recycler_;
+
   /// Asynchronous Completion Token (ACT) to be used to when talking to
   /// the recycler.
   const void *recycling_act_;
 };
+
 /**
  * @class ACE_Buffered_Svc_Handler
  *
@@ -232,8 +281,10 @@ public:
                             ACE_Reactor *reactor = ACE_Reactor::instance (),
                             size_t max_buffer_size = 0,
                             ACE_Time_Value *relative_timeout = 0);
+
   /// Destructor, which calls <flush>.
   virtual ~ACE_Buffered_Svc_Handler (void);
+
   /**
    * Insert the ACE_Message_Block chain rooted at @a message_block
    * into the ACE_Message_Queue with the designated @a timeout.  The
@@ -243,39 +294,53 @@ public:
    */
   virtual int put (ACE_Message_Block *message_block,
                    ACE_Time_Value *timeout = 0);
+
   /// Flush the ACE_Message_Queue, which writes all the queued
   /// ACE_Message_Blocks to the <PEER_STREAM>.
   virtual int flush (void);
+
   /// This method is not currently implemented -- this is where the
   /// integration with the <Reactor> would occur.
   virtual int handle_timeout (const ACE_Time_Value &time,
                               const void *);
+
   /// Dump the state of an object.
   void dump (void) const;
+
 protected:
   /// Implement the flush operation on the ACE_Message_Queue, which
   /// writes all the queued ACE_Message_Blocks to the <PEER_STREAM>.
   /// Assumes that the caller holds the lock.
   virtual int flush_i (void);
+
   /// Maximum size the <Message_Queue> can be before we have to flush
   /// the buffer.
   size_t maximum_buffer_size_;
+
   /// Current size in bytes of the <Message_Queue> contents.
   size_t current_buffer_size_;
+
   /// Timeout value used to control when the buffer is flushed.
   ACE_Time_Value next_timeout_;
+
   /// Interval of the timeout.
   ACE_Time_Value interval_;
+
   /// Timeout pointer.
   ACE_Time_Value *timeoutp_;
 };
+
 ACE_END_VERSIONED_NAMESPACE_DECL
+
 #if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
 #include "ace/Svc_Handler.cpp"
 #endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
 #if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
 #pragma implementation ("Svc_Handler.cpp")
 #endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
 #include /**/ "ace/post.h"
+
 #endif /* ACE_SVC_HANDLER_H */