Wed Aug 2 18:16:12 UTC 2006 Johnny Willemsen <jwillemsen@remedy.nl>

15 files changed, 66 insertions, 45 deletions

diff --git a/ACE/ChangeLog b/ACE/ChangeLog
index 817e86e9ddb..9087c1bbe99 100644
--- a/ACE/ChangeLog
+++ b/ACE/ChangeLog
@@ -1,3 +1,23 @@
+Wed Aug  2 18:16:12 UTC 2006  Johnny Willemsen  <jwillemsen@remedy.nl>
+
+        * ace/Connector.cpp:
+          Const improvements
+
+        * ace/Caching_Utility_T.h:
+        * ace/config-lite.h:
+        * ace/Event_Handler.h:
+        * ace/Framework_Component.h:
+        * ace/Lock.h:
+        * ace/Lock_Adapter_T.h:
+        * ace/Null_Mutex.h:
+        * ace/Object_Manager.h:
+        * ace/Object_Manager_Base.h:
+        * ace/Proactor.cpp:
+        * ace/Process_Manager.h:
+        * ace/Semaphore.h:
+        * ace/Thread_Exit.h:
+          Doxygen improvements
+
 Wed Aug  2 15:50:48 UTC 2006  Simon McQueen  <sm@prismtech.com>
 
         * bin/tao_other_tests.lst:
diff --git a/ACE/ace/Caching_Utility_T.h b/ACE/ace/Caching_Utility_T.h
index 0112e3f2b7d..9da0f7134ee 100644
--- a/ACE/ace/Caching_Utility_T.h
+++ b/ACE/ace/Caching_Utility_T.h
@@ -58,8 +58,8 @@ public:
   ~ACE_Pair_Caching_Utility (void);
 
   /**
-   * Purge entries from the <container>. The Cleanup_Strategy will do the actual
-   * job of cleanup once the entries to be cleaned up are decided.
+   * Purge entries from the @a container. The Cleanup_Strategy will do the
+   * actual job of cleanup once the entries to be cleaned up are decided.
    */
   int clear_cache (CONTAINER &container,
                    double purge_percent);
diff --git a/ACE/ace/Connector.cpp b/ACE/ace/Connector.cpp
index f588b605462..6eea42ee330 100644
--- a/ACE/ace/Connector.cpp
+++ b/ACE/ace/Connector.cpp
@@ -141,7 +141,7 @@ ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_input (ACE_HANDLE)
   ACE_TRACE ("ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_input");
 
   SVC_HANDLER *svc_handler = 0;
-  int retval = this->close (svc_handler) ? 0 : -1;
+  int const retval = this->close (svc_handler) ? 0 : -1;
 
   // Close Svc_Handler.
   if (svc_handler != 0)
@@ -159,7 +159,7 @@ ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_output (ACE_HANDLE handle)
   // Grab the connector ref before smashing ourselves in close().
   ACE_Connector_Base<SVC_HANDLER> &connector = this->connector_;
   SVC_HANDLER *svc_handler = 0;
-  int retval = this->close (svc_handler) ? 0 : -1;
+  int const retval = this->close (svc_handler) ? 0 : -1;
 
   if (svc_handler != 0)
     connector.initialize_svc_handler (handle, svc_handler);
@@ -370,7 +370,7 @@ ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_i
     return -1;
 
   ACE_Time_Value *timeout = 0;
-  int use_reactor = synch_options[ACE_Synch_Options::USE_REACTOR];
+  int const use_reactor = synch_options[ACE_Synch_Options::USE_REACTOR];
 
   if (use_reactor)
     timeout = const_cast<ACE_Time_Value *> (&ACE_Time_Value::zero);
diff --git a/ACE/ace/Event_Handler.h b/ACE/ace/Event_Handler.h
index b6b066cb379..d97a448e5b4 100644
--- a/ACE/ace/Event_Handler.h
+++ b/ACE/ace/Event_Handler.h
@@ -127,7 +127,7 @@ public:
   /// Called when a <handle_*()> method returns -1 or when the
   /// <remove_handler> method is called on an ACE_Reactor.  The
   /// <close_mask> indicates which event has triggered the
-  /// <handle_close> method callback on a particular <handle>.
+  /// <handle_close> method callback on a particular @a handle.
   virtual int handle_close (ACE_HANDLE handle,
                             ACE_Reactor_Mask close_mask);
 
@@ -178,7 +178,7 @@ public:
    * work around Win32 limitations that don't allow us to <select> on
    * non-sockets (such as ACE_STDIN).  This is commonly used in
    * situations where the Reactor is used to demultiplex read events
-   * on ACE_STDIN on UNIX.  Note that <event_handler> must be a
+   * on ACE_STDIN on UNIX.  Note that @a event_handler must be a
    * subclass of ACE_Event_Handler.  If the <get_handle> method of
    * this event handler returns <ACE_INVALID_HANDLE> we default to
    * reading from ACE_STDIN.
diff --git a/ACE/ace/Framework_Component.h b/ACE/ace/Framework_Component.h
index d0d2e6f89e2..fc6fc4f835d 100644
--- a/ACE/ace/Framework_Component.h
+++ b/ACE/ace/Framework_Component.h
@@ -8,7 +8,7 @@
  *
  * A prototype mechanism that allows framework components, singletons
  * such as ACE_Reactor, ACE_Proactor, etc, to be registered with a
- * central repository managed by the <ACE_Object_Manager> or
+ * central repository managed by the ACE_Object_Manager or
  * ACE_Service_Config that will handle destruction.
  *
  * This technique obviates changing ACE_Object_Manager and
diff --git a/ACE/ace/Lock.h b/ACE/ace/Lock.h
index 3a8eac292e4..7cbb88ea1ed 100644
--- a/ACE/ace/Lock.h
+++ b/ACE/ace/Lock.h
@@ -32,9 +32,9 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  * mechanisms.
  *
  * This class is typically used in conjunction with the
- * <ACE_Lock_Adapter> in order to provide a polymorphic
+ * ACE_Lock_Adapter in order to provide a polymorphic
  * interface to the ACE synchronization mechanisms (e.g.,
- * <ACE_Mutex>, <ACE_Semaphore>, <ACE_RW_Mutex>, etc).  Note that
+ * ACE_Mutex, ACE_Semaphore, ACE_RW_Mutex, etc).  Note that
  * the reason that all of ACE doesn't use polymorphic locks is
  * that (1) they add ~20% extra overhead for virtual function
  * calls and (2) objects with virtual functions can't be placed
diff --git a/ACE/ace/Lock_Adapter_T.h b/ACE/ace/Lock_Adapter_T.h
index 93ee250de4b..d6b6aa830dc 100644
--- a/ACE/ace/Lock_Adapter_T.h
+++ b/ACE/ace/Lock_Adapter_T.h
@@ -30,8 +30,8 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  * @brief This is an adapter that allows applications to transparently
  * combine the <ACE_Lock> abstract base class (which contains
  * pure virtual methods) with any of the other concrete ACE
- * synchronization classes (e.g., <ACE_Mutex>, <ACE_Semaphore>,
- * <ACE_RW_Mutex>, etc.).
+ * synchronization classes (e.g., ACE_Mutex, ACE_Semaphore,
+ * ACE_RW_Mutex, etc.).
  *
  * This class uses a form of the Adapter pattern.
  */
diff --git a/ACE/ace/Null_Mutex.h b/ACE/ace/Null_Mutex.h
index 022cc034df6..4d83ae67802 100644
--- a/ACE/ace/Null_Mutex.h
+++ b/ACE/ace/Null_Mutex.h
@@ -35,7 +35,7 @@ class ACE_Time_Value;
 /**
  * @class ACE_Null_Mutex
  *
- * @brief Implement a do nothing <ACE_Mutex>, i.e., all the methods are
+ * @brief Implement a do nothing ACE_Mutex, i.e., all the methods are
  * no ops.
  */
 class ACE_Null_Mutex
diff --git a/ACE/ace/Object_Manager.h b/ACE/ace/Object_Manager.h
index 70477591e56..f9d62b4025e 100644
--- a/ACE/ace/Object_Manager.h
+++ b/ACE/ace/Object_Manager.h
@@ -78,7 +78,7 @@ template <class T> class ACE_Cleanup_Adapter;
  *
  * @brief Manager for ACE library services and singleton cleanup.
  *
- * The <ACE_Object_Manager> manages cleanup of objects, typically
+ * The ACE_Object_Manager manages cleanup of objects, typically
  * singletons, at program termination.  In addition to managing
  * the cleanup of the ACE library, it provides an interface for
  * application to register objects to be cleaned up.
@@ -90,23 +90,23 @@ template <class T> class ACE_Cleanup_Adapter;
  * for cleanup, e.g., destruction.  The order of such cleanup
  * calls is in the reverse order of registration, i.e., that
  * last object/array to register gets cleaned up first.
- * The <ACE_Object_Manager> API includes <ACE_Managed_Object>.  That
+ * The ACE_Object_Manager API includes ACE_Managed_Object.  That
  * class is contained in a separate file because it is a
  * template class, and some compilers require that template and
  * non-template class definitions appear in separate files.
  * Please see ace/Managed_Object.h for a description of that
- * part of the API.  In summary, <ACE_Managed_Object> provides two
- * adapters, the <ACE_Cleanup_Adapter> and <ACE_Managed_Object>
+ * part of the API.  In summary, ACE_Managed_Object provides two
+ * adapters, the ACE_Cleanup_Adapter and ACE_Managed_Object
  * template classes for adapting objects of any type to be
- * easily managed by the <ACE_Object_Manager>.  There are several
+ * easily managed by the ACE_Object_Manager.  There are several
  * mechanisms for adapting objects and arrays for cleanup at
  * program termination, in roughly increasing order of ease-of-use:
- * 1) Derive the object's class from <ACE_Cleanup>.
- * 2) Allow the <ACE_Object_Manager> to both dynamically allocate
+ * 1) Derive the object's class from ACE_Cleanup.
+ * 2) Allow the ACE_Object_Manager to both dynamically allocate
  * and deallocate the object.
  * 3) Provide an <ACE_CLEANUP_FUNC> cleanup hook for the object or
  * array.
- * 4) Allow the <ACE_Object_Manager> to both preallocate the object
+ * 4) Allow the ACE_Object_Manager to both preallocate the object
  * or array, either statically in global data or dynamically on
  * the heap, when its singleton instance is construction.
  *
@@ -121,7 +121,7 @@ template <class T> class ACE_Cleanup_Adapter;
  * cleanup activity at program termination.
  * 2) ACE_Object_Manager::at_exit (ACE_Cleanup *object,
  * void *param = 0);
- * can be used to register an <ACE_Cleanup> object
+ * can be used to register an ACE_Cleanup object
  * for any cleanup activity at program termination.
  * The final mechanism is not general purpose, but can only
  * be used to allocate objects and arrays at program startup:
@@ -133,7 +133,7 @@ template <class T> class ACE_Cleanup_Adapter;
  * can only be used to allocate objects at program startup,
  * either in global data or on the heap (selected at compile
  * time).  These are intended to replace static locks, etc.
- * Instead of creating a static <ACE_Object_Manager> instance, one
+ * Instead of creating a static ACE_Object_Manager instance, one
  * can alternatively be created on the stack of the main program
  * thread.  It is created just after entry to ::main (int, char
  * *[]), and before any existing code in that function is
@@ -149,10 +149,10 @@ template <class T> class ACE_Cleanup_Adapter;
  * Note that the ACE_Object_Manager _must_ be created before
  * any threads are spawned by the program.
  * If ACE_HAS_NONSTATIC_OBJECT_MANAGER is not #defined, the ACE
- * library creates a static, singleton <ACE_Object_Manager> instance.
+ * library creates a static, singleton ACE_Object_Manager instance.
  * The instance is placed in global program data, and constructed
  * via a static object constructor.  If ACE_HAS_NONSTATIC_OBJECT_MANAGER
- * is #defined, the <ACE_Object_Manager> instance is created on the stack
+ * is #defined, the ACE_Object_Manager instance is created on the stack
  * of the main program thread, as noted above.
  *
  * With ACE_HAS_NONSTATIC_OBJECT_MANAGER enabled, the ACE
@@ -168,7 +168,7 @@ template <class T> class ACE_Cleanup_Adapter;
  * NOTE on the use of <::exit> -- <::exit> does not destroy
  * automatic objects.  Therefore, if
  * ACE_HAS_NONSTATIC_OBJECT_MANAGER is enabled, the
- * <ACE_Object_Manager> instance will *not* be destroyed if
+ * ACE_Object_Manager instance will *not* be destroyed if
  * <::exit> is called!  However, <ACE_OS::exit> will properly
  * destroy the ACE_Object_Manager.  It is highly recommended
  * that <ACE_OS::exit> be used instead of <::exit>.
@@ -185,7 +185,7 @@ template <class T> class ACE_Cleanup_Adapter;
  * destroy automatic objects, and for developing the
  * recommendations in this paragraph.
  *
- * Instead of creating a static <ACE_Object_Manager>, or letting
+ * Instead of creating a static ACE_Object_Manager, or letting
  * ACE create it on the stack of <main> for you, another
  * alternative is to #define
  * ACE_DOESNT_INSTANTIATE_NONSTATIC_OBJECT_MANAGER.  With that
@@ -193,7 +193,7 @@ template <class T> class ACE_Cleanup_Adapter;
  * The recommended way is to call <ACE::init> at the start of
  * the program, and call <ACE::fini> at the end.  Alternatively,
  * the application could explicity construct an
- * <ACE_Object_Manager>.
+ * ACE_Object_Manager.
  */
 class ACE_Export ACE_Object_Manager : public ACE_Object_Manager_Base
 {
@@ -360,7 +360,7 @@ public:
   static int get_singleton_lock (ACE_Thread_Mutex *&);
 
   /**
-   * Accesses a non-recursive <ACE_Mutex> to be used for construction
+   * Accesses a non-recursive ACE_Mutex to be used for construction
    * of <ACE_Singletons>.  Returns 0, and the lock in the argument, on
    * success; returns -1 on failure.
    */
@@ -374,7 +374,7 @@ public:
   static int get_singleton_lock (ACE_Recursive_Thread_Mutex *&);
 
   /**
-   * Accesses a readers/writer <ACE_RW_Thread_Mutex> to be used for
+   * Accesses a readers/writer ACE_RW_Thread_Mutex to be used for
    * construction of <ACE_Singletons>.  Returns 0, and the lock in the
    * argument, on success; returns -1 on failure.
    */
diff --git a/ACE/ace/Object_Manager_Base.h b/ACE/ace/Object_Manager_Base.h
index f02accb2d42..a2619db7abd 100644
--- a/ACE/ace/Object_Manager_Base.h
+++ b/ACE/ace/Object_Manager_Base.h
@@ -192,7 +192,7 @@ public:
 public:
   // = Applications shouldn't use these so they're hidden here.
 
-  // They're public so that the <ACE_Object_Manager> can be
+  // They're public so that the ACE_Object_Manager can be
   // constructed/destructed in <main> with
   // <ACE_HAS_NONSTATIC_OBJECT_MANAGER>.
   /// Constructor.
diff --git a/ACE/ace/Proactor.h b/ACE/ace/Proactor.h
index 2b5f6f750d1..a9062c2488e 100644
--- a/ACE/ace/Proactor.h
+++ b/ACE/ace/Proactor.h
@@ -202,7 +202,7 @@ public:
   /// Delete the dynamically allocated Singleton.
   static void close_singleton (void);
 
-  /// Cleanup method, used by the <ACE_Object_Manager> to destroy the
+  /// Cleanup method, used by the ACE_Object_Manager to destroy the
   /// singleton.
   static void cleanup (void *instance, void *arg);
 
diff --git a/ACE/ace/Process_Manager.h b/ACE/ace/Process_Manager.h
index 050c2f47e2e..e42b4f90276 100644
--- a/ACE/ace/Process_Manager.h
+++ b/ACE/ace/Process_Manager.h
@@ -172,7 +172,7 @@ public:
   /// Delete the dynamically allocated singleton.
   static void close_singleton (void);
 
-  /// Cleanup method, used by the <ACE_Object_Manager> to destroy the
+  /// Cleanup method, used by the ACE_Object_Manager to destroy the
   /// singleton.
   static void cleanup (void *instance, void *arg);
 
diff --git a/ACE/ace/Semaphore.h b/ACE/ace/Semaphore.h
index afee6043bbd..eb70b5ac0b2 100644
--- a/ACE/ace/Semaphore.h
+++ b/ACE/ace/Semaphore.h
@@ -60,10 +60,10 @@ public:
 
   /**
    * Block the thread until the semaphore count becomes greater than 0
-   * (at which point it is decremented) or until <tv> times out (in
-   * which case -1 is returned and <errno> == <ETIME>).  Note that <tv>
+   * (at which point it is decremented) or until @a tv times out (in
+   * which case -1 is returned and <errno> == <ETIME>).  Note that @a tv
    * is assumed to be in "absolute" rather than "relative" time.  The
-   * value of <tv> is updated upon return to show the actual
+   * value of @a tv is updated upon return to show the actual
    * (absolute) acquisition time.
    *
    * @note Solaris threads do not support timed semaphores.
@@ -71,7 +71,8 @@ public:
    * consider using the ACE POSIX pthreads implementation instead,
    * which can be enabled by compiling ACE with
    * -DACE_HAS_PTHREADS, rather than -DACE_HAS_STHREADS or
-   * -DACE_HAS_POSIX_SEM. */
+   * -DACE_HAS_POSIX_SEM.
+   */
   int acquire (ACE_Time_Value &tv);
 
   /**
@@ -103,27 +104,27 @@ public:
   /// thread.
   int release (void);
 
-  /// Increment the semaphore by <release_count>, potentially
+  /// Increment the semaphore by @a release_count, potentially
   /// unblocking waiting threads.
   int release (unsigned int release_count);
 
   /**
    * Acquire semaphore ownership.  This calls <acquire> and is only
-   * here to make the <ACE_Semaphore> interface consistent with the
+   * here to make the ACE_Semaphore interface consistent with the
    * other synchronization APIs.
    */
   int acquire_read (void);
 
   /**
    * Acquire semaphore ownership.  This calls <acquire> and is only
-   * here to make the <ACE_Semaphore> interface consistent with the
+   * here to make the ACE_Semaphore interface consistent with the
    * other synchronization APIs.
    */
   int acquire_write (void);
 
   /**
    * Conditionally acquire semaphore (i.e., won't block).  This calls
-   * <tryacquire> and is only here to make the <ACE_Semaphore>
+   * <tryacquire> and is only here to make the ACE_Semaphore
    * interface consistent with the other synchronization APIs.
    * Returns -1 on failure.  If we "failed" because someone else
    * already had the lock, <errno> is set to <EBUSY>.
@@ -132,7 +133,7 @@ public:
 
   /**
    * Conditionally acquire semaphore (i.e., won't block).  This calls
-   * <tryacquire> and is only here to make the <ACE_Semaphore>
+   * <tryacquire> and is only here to make the ACE_Semaphore
    * interface consistent with the other synchronization APIs.
    * Returns -1 on failure.  If we "failed" because someone else
    * already had the lock, <errno> is set to <EBUSY>.
@@ -140,7 +141,7 @@ public:
   int tryacquire_write (void);
 
   /**
-   * This is only here to make the <ACE_Semaphore>
+   * This is only here to make the ACE_Semaphore
    * interface consistent with the other synchronization APIs.
    * Assumes the caller has already acquired the semaphore using one of
    * the above calls, and returns 0 (success) always.
diff --git a/ACE/ace/Thread_Exit.h b/ACE/ace/Thread_Exit.h
index fc828c5aa03..99da0712ac1 100644
--- a/ACE/ace/Thread_Exit.h
+++ b/ACE/ace/Thread_Exit.h
@@ -55,7 +55,7 @@ public:
   /// Singleton access point.
   static ACE_Thread_Exit *instance (void);
 
-  /// Cleanup method, used by the <ACE_Object_Manager> to destroy the
+  /// Cleanup method, used by the ACE_Object_Manager to destroy the
   /// singleton.
   static void cleanup (void *instance);
 
diff --git a/ACE/ace/config-lite.h b/ACE/ace/config-lite.h
index 117933cbe61..cd121771c86 100644
--- a/ACE/ace/config-lite.h
+++ b/ACE/ace/config-lite.h
@@ -58,7 +58,7 @@ extern "C"
 }
 
 // Signature for registering a cleanup function that is used by the
-// <ACE_Object_Manager> and the <ACE_Thread_Manager>.
+// ACE_Object_Manager and the <ACE_Thread_Manager>.
 # if defined (ACE_HAS_SIG_C_FUNC)
 extern "C" {
 # endif /* ACE_HAS_SIG_C_FUNC */