ChangeLogTag: Thu Apr 27 11:17:12 UTC 2006 Johnny Willemsen <jwillemsen@remedy.nl>

20 files changed, 65 insertions, 66 deletions

diff --git a/ace/ATM_Addr.h b/ace/ATM_Addr.h
index c3f112e8c1c..551b5ca1b5c 100644
--- a/ace/ATM_Addr.h
+++ b/ace/ATM_Addr.h
@@ -74,7 +74,7 @@ public:
                 u_char selector = DEFAULT_SELECTOR);
 
   /**
-   * Creates an <ACE_ATM_Addr> from an ATMSAPAddress structure. This
+   * Creates an ACE_ATM_Addr from an ATMSAPAddress structure. This
    * is vendor specific (FORE systems). May need to change when other
    * vendors are supported.
    */
@@ -82,7 +82,7 @@ public:
                 u_char selector = DEFAULT_SELECTOR);
 
   /**
-   * Initializes an <ACE_ATM_Addr> from the <sap> which can be
+   * Initializes an ACE_ATM_Addr from the <sap> which can be
    * "atm-address" (e.g.,
    * "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00") or "hostname"
    * (e.g., "frisbee.cs.wustl.edu").
@@ -98,12 +98,12 @@ public:
   /// t_atm_sap_addr.SVE_tag_addr, t_atm_sap_addr.SVE_tag_selector)
   void init (u_char selector = DEFAULT_SELECTOR);
 
-  /// Initializes from another <ACE_ATM_Addr>.
+  /// Initializes from another ACE_ATM_Addr.
   int set (const ACE_ATM_Addr &,
            u_char selector = DEFAULT_SELECTOR);
 
   /**
-   * Initializes an <ACE_ATM_Addr> from an ATMSAPAddress/sockaddr_atm
+   * Initializes an ACE_ATM_Addr from an ATMSAPAddress/sockaddr_atm
    * structure. This is vendor specific (FORE systems). May need to
    * change when other vendors are supported.
    */
@@ -111,7 +111,7 @@ public:
            u_char selector = DEFAULT_SELECTOR);
 
   /**
-   * Initializes an <ACE_ATM_Addr> from the <sap> which can be
+   * Initializes an ACE_ATM_Addr from the <sap> which can be
    * "atm-address" (e.g.,
    * "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00") or "hostname"
    * (e.g., "frisbee.cs.wustl.edu").
@@ -120,7 +120,7 @@ public:
            u_char selector = DEFAULT_SELECTOR);
 
   /**
-   * Initializes an <ACE_ATM_Addr> from the <sap> which can be
+   * Initializes an ACE_ATM_Addr from the <sap> which can be
    * "atm-address" (e.g.,
    * "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00") or "hostname"
    * (e.g., "frisbee.cs.wustl.edu").
diff --git a/ace/Array_Map.h b/ace/Array_Map.h
index 3425e917d4c..06729141183 100644
--- a/ace/Array_Map.h
+++ b/ace/Array_Map.h
@@ -219,7 +219,7 @@ public:
 
   /// Remove range of elements [@a first, @a last) from the map.
   /**
-   * @note [@a first, @last) must be valid range within the map.
+   * @note [@a first, @a last) must be valid range within the map.
    */
   void erase (iterator first, iterator last);
 
diff --git a/ace/Atomic_Op_T.h b/ace/Atomic_Op_T.h
index 89703186356..549ee67274b 100644
--- a/ace/Atomic_Op_T.h
+++ b/ace/Atomic_Op_T.h
@@ -112,7 +112,7 @@ public:
    * Returns a reference to the underlying <ACE_LOCK>.  This makes it
    * possible to acquire the lock explicitly, which can be useful in
    * some cases if you instantiate the <ACE_Atomic_Op_Ex> with an
-   * <ACE_Recursive_Mutex> or <ACE_Process_Mutex>.  @note the right
+   * ACE_Recursive_Mutex or ACE_Process_Mutex.  @note the right
    * name would be lock_, but HP/C++ will choke on that!
    */
   ACE_LOCK &mutex (void);
@@ -211,8 +211,8 @@ public:
   /**
    * Returns a reference to the underlying <ACE_LOCK>.  This makes it
    * possible to acquire the lock explicitly, which can be useful in
-   * some cases if you instantiate the <ACE_Atomic_Op> with an
-   * <ACE_Recursive_Mutex> or <ACE_Process_Mutex>.
+   * some cases if you instantiate the ACE_Atomic_Op with an
+   * ACE_Recursive_Mutex or ACE_Process_Mutex.
    *
    * @deprecated This member function is deprecated and so may go away in
    * the future. If you need access to the underlying mutex, consider
diff --git a/ace/Base_Thread_Adapter.h b/ace/Base_Thread_Adapter.h
index 25b44e382c2..9eda6e877a5 100644
--- a/ace/Base_Thread_Adapter.h
+++ b/ace/Base_Thread_Adapter.h
@@ -127,7 +127,7 @@ protected:
 # endif /* ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS */
                       );
   /// Inherit the logging features if the parent thread has an
-  /// <ACE_Log_Msg>.
+  /// ACE_Log_Msg.
   void inherit_log_msg (void);
 
 private:
diff --git a/ace/Cached_Connect_Strategy_T.h b/ace/Cached_Connect_Strategy_T.h
index f04392846cb..4d928e57f54 100644
--- a/ace/Cached_Connect_Strategy_T.h
+++ b/ace/Cached_Connect_Strategy_T.h
@@ -40,7 +40,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  * subsequent re-use of unused, but available, connections.
  *
  * <Cached_Connect_Strategy> is intended to be used as a
- * plug-in connection strategy for <ACE_Strategy_Connector>.
+ * plug-in connection strategy for ACE_Strategy_Connector.
  * It's added value is re-use of established connections and
  * tweaking the role of the cache as per the caching strategy.
  */
@@ -191,7 +191,7 @@ protected:
  *     maximum size.
  *
  *       <Bounded_Cached_Connect_Strategy> is intended to be used as a
- *     plug-in connection strategy for <ACE_Strategy_Connector>.
+ *     plug-in connection strategy for ACE_Strategy_Connector.
  *     It's added value is re-use of established connections and
  *     tweaking the role of the cache as per the caching strategy.
  *     Thanks to Edan Ayal  <edana@bandwiz.com> for contributing this
diff --git a/ace/Capabilities.h b/ace/Capabilities.h
index a970722e803..609f3ddaa06 100644
--- a/ace/Capabilities.h
+++ b/ace/Capabilities.h
@@ -124,12 +124,12 @@ protected:
  * This is a container class for ACE Capabilities
  * values. Currently exist three different capability values:
  * <ACE_IntCapEntry> (integer), <ACE_BoolCapEntry> (bool) and
- * <ACE_StringCapEntry> (String).  An <ACE_Capabilities> is a
+ * <ACE_StringCapEntry> (String).  An ACE_Capabilities is a
  * unordered set of pair = (<String>, <ACE_CapEntry> *).  Where
  * the first component is the name of capability and the second
  * component is a pointer to the capability value container.  A
- * <FILE> is a container for <ACE_Capabilities>, the
- * <ACE_Capabilities> has a name in the file, as a termcap file.
+ * <FILE> is a container for ACE_Capabilities, the
+ * ACE_Capabilities has a name in the file, as a termcap file.
  */
 class ACE_Export ACE_Capabilities
 {
diff --git a/ace/Default_Constants.h b/ace/Default_Constants.h
index 945e9ff3513..ae2bbc9b119 100644
--- a/ace/Default_Constants.h
+++ b/ace/Default_Constants.h
@@ -448,7 +448,7 @@
 #endif /* ACE_MAX_DEFAULT_PORT */
 
 // Default number of ACE_Event_Handlers supported by
-// <ACE_Timer_Heap>.
+// ACE_Timer_Heap.
 # if !defined (ACE_DEFAULT_TIMERS)
 #   define ACE_DEFAULT_TIMERS _POSIX_TIMER_MAX
 # endif /* ACE_DEFAULT_TIMERS */
diff --git a/ace/Hash_Map_Manager_T.h b/ace/Hash_Map_Manager_T.h
index 23ce8d690ec..5bd83664298 100644
--- a/ace/Hash_Map_Manager_T.h
+++ b/ace/Hash_Map_Manager_T.h
@@ -308,8 +308,8 @@ public:
   /**
    * Returns a reference to the underlying <ACE_LOCK>.  This makes it
    * possible to acquire the lock explicitly, which can be useful in
-   * some cases if you instantiate the <ACE_Atomic_Op> with an
-   * <ACE_Recursive_Mutex> or <ACE_Process_Mutex>, or if you need to
+   * some cases if you instantiate the ACE_Atomic_Op with an
+   * ACE_Recursive_Mutex or ACE_Process_Mutex, or if you need to
    * guard the state of an iterator.
    * @note The right name would be <lock>, but HP/C++ will choke on that!
    */
diff --git a/ace/Log_Msg_Callback.h b/ace/Log_Msg_Callback.h
index 2d3af46a1b3..182186ac1ae 100644
--- a/ace/Log_Msg_Callback.h
+++ b/ace/Log_Msg_Callback.h
@@ -42,7 +42,7 @@ class ACE_Log_Record;
  *
  *     Remember that there is one Log_Msg object per thread.
  *     Therefore, you may need to register your callback object with
- *     many <ACE_Log_Msg> objects (and have the correct
+ *     many ACE_Log_Msg objects (and have the correct
  *     synchronization in the <log> method) or have a separate
  *     callback object per Log_Msg object.  Moreover,
  *     <ACE_Log_Msg_Callbacks> are not inherited when a new thread
diff --git a/ace/Log_Msg_IPC.h b/ace/Log_Msg_IPC.h
index 2b05c02de02..b50b04c05ce 100644
--- a/ace/Log_Msg_IPC.h
+++ b/ace/Log_Msg_IPC.h
@@ -21,7 +21,7 @@
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
 // IPC conduit between sender and client daemon.  This should be
-// included in the <ACE_Log_Msg> class, but due to "order of include"
+// included in the ACE_Log_Msg class, but due to "order of include"
 // problems it can't be...
 #if defined (ACE_HAS_STREAM_PIPES)
 # include "ace/SPIPE_Connector.h"
diff --git a/ace/Map_Manager.h b/ace/Map_Manager.h
index 847c7167e2c..b4722c34864 100644
--- a/ace/Map_Manager.h
+++ b/ace/Map_Manager.h
@@ -262,8 +262,8 @@ public:
   /**
    * Returns a reference to the underlying <ACE_LOCK>.  This makes it
    * possible to acquire the lock explicitly, which can be useful in
-   * some cases if you instantiate the <ACE_Atomic_Op> with an
-   * <ACE_Recursive_Mutex> or <ACE_Process_Mutex>, or if you need to
+   * some cases if you instantiate the ACE_Atomic_Op with an
+   * ACE_Recursive_Mutex or ACE_Process_Mutex, or if you need to
    * guard the state of an iterator.
    * @note The right name would be <lock>, but HP/C++ will choke on that!
    */
diff --git a/ace/POSIX_Asynch_IO.h b/ace/POSIX_Asynch_IO.h
index 57eb53e169c..8e6e0be88fd 100644
--- a/ace/POSIX_Asynch_IO.h
+++ b/ace/POSIX_Asynch_IO.h
@@ -151,18 +151,17 @@ protected:
 /**
  * @class ACE_POSIX_Asynch_Operation
  *
- * @brief This class implements <ACE_Asynch_Operation> for all
+ * @brief This class implements ACE_Asynch_Operation for all
  * implementations of Proactor (AIOCB, SIG, SUN)
- * Specific future implementations
- * can derive from this class.
+ * Specific future implementations can derive from this class.
  */
 class ACE_Export ACE_POSIX_Asynch_Operation : public virtual ACE_Asynch_Operation_Impl
 {
 public:
   /**
    * Initializes the factory with information which will be used with
-   * each asynchronous call.  If (<handle> == ACE_INVALID_HANDLE),
-   * <ACE_Handler::handle> will be called on the <handler> to get the
+   * each asynchronous call.  If (@a handle == ACE_INVALID_HANDLE),
+   * @c ACE_Handler::handle will be called on the handler to get the
    * correct handle. No need for the Proactor since the sub classes
    * will know the correct implementation Proactor class, since this
    * Operation class itself was created by the correct implementation
@@ -173,7 +172,7 @@ public:
             const void *completion_key,
             ACE_Proactor *proactor = 0);
 
-  /// Check the documentation for <ACE_Asynch_Operation::cancel>.
+  /// Check the documentation for ACE_Asynch_Operation::cancel.
   int cancel (void);
 
   // = Access methods.
@@ -192,7 +191,7 @@ protected:
   virtual ~ACE_POSIX_Asynch_Operation (void);
 
   // This call is for the POSIX implementation. This method is used by
-  // <ACE_Asynch_Operation> to store some information with the
+  // ACE_Asynch_Operation to store some information with the
   // Proactor after an <aio_> call is issued, so that the Proactor can
   // retreve this information to do <aio_return> and <aio_error>.
   // Passing a '0' ptr returns the status, indicating whether there
@@ -587,11 +586,11 @@ private:
  * @class ACE_POSIX_Asynch_Accept_Result
  *
  * @brief This is that class which will be passed back to the
- *     <handler> when the asynchronous accept completes.
+ *     handler when the asynchronous accept completes.
  *
  *
  *     This class has all the information necessary for the
- *     <handler> to uniquiely identify the completion of the
+ *     handler to uniquiely identify the completion of the
  *     asynchronous accept.
  */
 class ACE_Export ACE_POSIX_Asynch_Accept_Result : public virtual ACE_Asynch_Accept_Result_Impl,
diff --git a/ace/POSIX_Proactor.h b/ace/POSIX_Proactor.h
index e56a2f28409..a1ff00288a3 100644
--- a/ace/POSIX_Proactor.h
+++ b/ace/POSIX_Proactor.h
@@ -614,8 +614,8 @@ protected:
  * @class ACE_POSIX_Asynch_Timer
  *
  * @brief This class is posted to the completion port when a timer
- * expires. When the <complete method> of this object is
- * called, the <handler>'s <handle_timeout> method will be
+ * expires. When the @c complete() method of this object is
+ * called, the handler's @c handle_timeout() method will be
  * called.
  */
 class ACE_Export ACE_POSIX_Asynch_Timer : public ACE_POSIX_Asynch_Result
@@ -640,7 +640,7 @@ protected:
   /// Destructor.
   virtual ~ACE_POSIX_Asynch_Timer (void) {}
 
-  /// This method calls the <handler>'s handle_timeout method.
+  /// This method calls the handler's handle_timeout method.
   virtual void complete (size_t bytes_transferred,
                          int success,
                          const void *completion_key,
diff --git a/ace/RB_Tree.h b/ace/RB_Tree.h
index 5c63d0b51ee..16db8fc081d 100644
--- a/ace/RB_Tree.h
+++ b/ace/RB_Tree.h
@@ -370,8 +370,8 @@ public:
   /**
    * Returns a reference to the underlying <ACE_LOCK>.  This makes it
    * possible to acquire the lock explicitly, which can be useful in
-   * some cases if you instantiate the <ACE_Atomic_Op> with an
-   * <ACE_Recursive_Mutex> or <ACE_Process_Mutex>, or if you need to
+   * some cases if you instantiate the ACE_Atomic_Op with an
+   * ACE_Recursive_Mutex or ACE_Process_Mutex, or if you need to
    * guard the state of an iterator.
    * @note The right name would be <lock>, but HP/C++ will choke on that!
    */
diff --git a/ace/Strategies_T.h b/ace/Strategies_T.h
index 8171bf8b07f..b9e7e6b9139 100644
--- a/ace/Strategies_T.h
+++ b/ace/Strategies_T.h
@@ -414,13 +414,13 @@ protected:
  * @class ACE_Process_Strategy
  *
  * @brief Defines the interface for specifying a concurrency strategy
- * for a <SVC_HANDLER> based on multiprocessing.
+ * for a @c SVC_HANDLER based on multiprocessing.
  *
  * This class provides a strategy that manages the creation of
  * processes to handle requests from clients concurrently using a
  * process-per-connection model.  It behaves as a "process factory",
- * using <ACE::fork> to fork threads "on-demand" to run the service
- * specified by a user-supplied <SVC_HANDLER> in a separate process.
+ * using @c ACE::fork() to fork threads "on-demand" to run the service
+ * specified by a user-supplied @c SVC_HANDLER in a separate process.
  */
 template <class SVC_HANDLER>
 class ACE_Process_Strategy : public ACE_Concurrency_Strategy<SVC_HANDLER>
@@ -432,15 +432,15 @@ public:
 
   // = Intialization and termination methods.
 
-  /// Initialize the strategy.  If <avoid_zombies> is non-0 then set a
-  /// flag to <ACE::fork> to avoid zombies.
+  /// Initialize the strategy.  If @a avoid_zombies is non-0 then set a
+  /// flag to ACE::fork() to avoid zombies.
   ACE_Process_Strategy (size_t n_processes = 1,
                         ACE_Event_Handler *acceptor = 0,
                         ACE_Reactor * = 0,
                         int avoid_zombies = 0);
 
-  /// Initialize the strategy.  If <avoid_zombies> is non-0 then set a
-  /// flag to <ACE::fork> to avoid zombies.
+  /// Initialize the strategy.  If @a avoid_zombies is non-0 then set a
+  /// flag to ACE::fork() to avoid zombies.
   virtual int open (size_t n_processes = 1,
                     ACE_Event_Handler *acceptor = 0,
                     ACE_Reactor * = 0,
@@ -450,9 +450,9 @@ public:
 
   // = Factory method.
   /**
-   * Activate the <svc_handler> with an appropriate concurrency
+   * Activate the @a svc_handler with an appropriate concurrency
    * strategy.  This method activates the SVC_HANDLER by first forking
-   * and then calling the <open> method of the SVC_HANDLER in the
+   * and then calling the @c open() method of the SVC_HANDLER in the
    * child.
    */
   virtual int activate_svc_handler (SVC_HANDLER *svc_handler,
@@ -471,15 +471,15 @@ protected:
   size_t n_processes_;
 
   /**
-   * This is the <Acceptor> in the parent is listening on.  We need to
+   * This is the @c Acceptor in the parent is listening on.  We need to
    * make sure that we remove it from the Reactor and close it down in
    * the child.
    */
   ACE_Event_Handler *acceptor_;
 
   /**
-   * This is the <Reactor> the child is using in conjunction with the
-   * <Acceptor>.  We need to remove the <Acceptor> from this <Reactor>
+   * This is the reactor the child is using in conjunction with the
+   * acceptor.  We need to remove the acceptor from this reactor
    * in the child.
    */
   ACE_Reactor *reactor_;
@@ -509,13 +509,13 @@ public:
   /// Default constructor.
   ACE_Accept_Strategy (ACE_Reactor *reactor = ACE_Reactor::instance ());
 
-  /// Initialize the <peer_acceptor_> with <local_addr>.
+  /// Initialize the @c peer_acceptor_ with @a local_addr.
   ACE_Accept_Strategy (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
                        int restart = 0,
                        ACE_Reactor *reactor = ACE_Reactor::instance ());
 
-  /// Initialize the <peer_acceptor_> with <local_addr>, indicating
-  /// whether to <reuse_addr> if it's already in use.
+  /// Initialize the <peer_acceptor_> with @a local_addr, indicating
+  /// whether to @a reuse_addr if it's already in use.
   virtual int open (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
                     int reuse_addr = 0);
 
@@ -822,7 +822,7 @@ protected:
  * subsequent re-use of unused, but available, connections.
  *
  * <ACE_Cached_Connect_Strategy> is intended to be used as a
- * plug-in connection strategy for <ACE_Strategy_Connector>.
+ * plug-in connection strategy for ACE_Strategy_Connector.
  * It's added value is re-use of established connections.
  */
 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX>
diff --git a/ace/Timer_Heap_T.h b/ace/Timer_Heap_T.h
index 068aa0bfb67..efe29a0f5f3 100644
--- a/ace/Timer_Heap_T.h
+++ b/ace/Timer_Heap_T.h
@@ -61,7 +61,7 @@ public:
   virtual ACE_Timer_Node_T<TYPE> *item (void);
 
 protected:
-  /// Pointer to the <ACE_Timer_Heap> that we are iterating over.
+  /// Pointer to the ACE_Timer_Heap that we are iterating over.
   ACE_Timer_Heap_T<TYPE, FUNCTOR, ACE_LOCK> &timer_heap_;
 
   /// Position in the array where the iterator is at
diff --git a/ace/Timer_List_T.h b/ace/Timer_List_T.h
index 3b85b985801..763ef9c905c 100644
--- a/ace/Timer_List_T.h
+++ b/ace/Timer_List_T.h
@@ -75,11 +75,11 @@ protected:
  * expiring timers is O(K) (where K is the total number of timers
  * that are < the current time of day).
  * More clever implementations could use a delta-list, a heap,
- * or timing wheels, etc.  For instance, <ACE_Timer_Heap>
- * is a subclass of <ACE_Timer_List> that implements a
+ * or timing wheels, etc.  For instance, ACE_Timer_Heap
+ * is a subclass of ACE_Timer_List that implements a
  * heap-based callout queue.  For most applications, the
- * <ACE_Timer_Heap> will perform substantially faster than the
- * <ACE_Timer_List>.
+ * ACE_Timer_Heap will perform substantially faster than the
+ * ACE_Timer_List.
  */
 template <class TYPE, class FUNCTOR, class ACE_LOCK>
 class ACE_Timer_List_T : public ACE_Timer_Queue_T<TYPE, FUNCTOR, ACE_LOCK>
diff --git a/ace/Timer_Queue_Adapters.h b/ace/Timer_Queue_Adapters.h
index d2ff5946c3a..ab25c490737 100644
--- a/ace/Timer_Queue_Adapters.h
+++ b/ace/Timer_Queue_Adapters.h
@@ -82,18 +82,18 @@ private:
   /// Perform the logic to compute the new ualarm(2) setting.
   virtual int schedule_ualarm (void);
 
-  /// Called back by <SIGALRM> handler.
+  /// Called back by @c SIGALRM handler.
   virtual int handle_signal (int signum, siginfo_t *, ucontext_t *);
 
-  /// Handler for the <SIGALRM> signal, so that we can access our state
+  /// Handler for the @c SIGALRM signal, so that we can access our state
   /// without requiring any global variables.
   ACE_Sig_Handler sig_handler_;
 
-  /// Implementation of the timer queue (e.g., <ACE_Timer_List>,
-  /// <ACE_Timer_Heap>, etc.).
+  /// Implementation of the timer queue (e.g., ACE_Timer_List,
+  /// ACE_Timer_Heap, etc.).
   TQ timer_queue_;
 
-  /// Mask of signals to be blocked when we're servicing <SIGALRM>.
+  /// Mask of signals to be blocked when we're servicing @c SIGALRM.
   ACE_Sig_Set mask_;
 };
 
diff --git a/ace/Timer_Queue_T.h b/ace/Timer_Queue_T.h
index 604079a41da..f780d8a5240 100644
--- a/ace/Timer_Queue_T.h
+++ b/ace/Timer_Queue_T.h
@@ -200,8 +200,8 @@ public:
  * @brief Provides an interface to timers.
  *
  * This is an abstract base class that provides hook for
- * implementing specialized policies such as <ACE_Timer_List>
- * and <ACE_Timer_Heap>.
+ * implementing specialized policies such as ACE_Timer_List
+ * and ACE_Timer_Heap.
  */
 template <class TYPE, class FUNCTOR, class ACE_LOCK>
 class ACE_Timer_Queue_T
diff --git a/ace/Timer_Wheel_T.h b/ace/Timer_Wheel_T.h
index 5c62a39dde0..984ad6d8bb7 100644
--- a/ace/Timer_Wheel_T.h
+++ b/ace/Timer_Wheel_T.h
@@ -62,7 +62,7 @@ public:
   virtual ACE_Timer_Node_T<TYPE>* item (void);
 
 protected:
-  /// Pointer to the <ACE_Timer_List> that we are iterating over.
+  /// Pointer to the ACE_Timer_List that we are iterating over.
   Wheel& timer_wheel_;
 
   /// Current position in the timing wheel