ChangeLogTag: Wed Nov 27 09:27:12 UTC 2002 Johnny Willemsen <jwillemsen@remedy.nl>

2 files changed, 57 insertions, 58 deletions

diff --git a/ace/DLL.h b/ace/DLL.h
index 8d9c49ca30a..1911f9993b6 100644
--- a/ace/DLL.h
+++ b/ace/DLL.h
@@ -31,8 +31,8 @@ class ACE_DLL_Handle;
  *
  * This class is an wrapper over the various methods for utilizing
  * a dynamically linked library (DLL), which is called a shared
- * library on some platforms.  Operations <open>, <close>, and
- * <symbol> have been implemented to help opening/closing and
+ * library on some platforms.  Operations open(), close(), and
+ * symbol() have been implemented to help opening/closing and
  * extracting symbol information from a DLL, respectively.
  */
 class ACE_Export ACE_DLL
@@ -40,16 +40,16 @@ class ACE_Export ACE_DLL
 public:
   // = Initialization and termination methods.
 
-  /// Default constructor.  By default, the <close> operation on the
+  /// Default constructor.  By default, the close() operation on the
   /// object will be invoked before it is destroyed.
   ACE_DLL (int close_on_destruction = 1);
 
   /**
-   * This constructor opens and dynamically links <dll_name>.  The
+   * This constructor opens and dynamically links @a dll_name.  The
    * default mode is <RTLD_LAZY>, which loads identifier symbols but
    * not the symbols for functions, which are loaded dynamically
    * on-demand.  Other supported modes include: <RTLD_NOW>, which
-   * performs all necessary relocations when <dll_name> is first
+   * performs all necessary relocations when @a dll_name is first
    * loaded and <RTLD_GLOBAL>, which makes symbols available for
    * relocation processing of any other DLLs.
    */
@@ -61,14 +61,15 @@ public:
   ACE_DLL (const ACE_DLL &);
 
   /**
-   * This method opens and dynamically links <dll_name>.  The default
+   * This method opens and dynamically links @a dll_name.  The default
    * mode is <RTLD_LAZY>, which loads identifier symbols but not the
    * symbols for functions, which are loaded dynamically on-demand.
    * Other supported modes include: <RTLD_NOW>, which performs all
-   * necessary relocations when <dll_name> is first loaded and
+   * necessary relocations when @a dll_name>is first loaded and
    * <RTLD_GLOBAL>, which makes symbols available for relocation
-   * processing of any other DLLs.  Returns -1 on failure and 0 on
-   * success.
+   * processing of any other DLLs.
+   * @retval -1 On failure
+   * @retval 0 On success.
    */
   int open (const ACE_TCHAR *dll_name,
             int open_mode = ACE_DEFAULT_SHLIB_MODE,
@@ -78,14 +79,14 @@ public:
   int close (void);
 
   /**
-   * Called when the DLL object is destroyed -- invokes <close> if the
-   * <close_on_destruction> flag is set in the constructor or <open>
+   * Called when the DLL object is destroyed -- invokes close() if the
+   * <close_on_destruction> flag is set in the constructor or open()
    * method.
    */
   ~ACE_DLL (void);
 
-  /// If <symbol_name> is in the symbol table of the DLL a pointer to
-  /// the <symbol_name> is returned.  Otherwise, returns 0.  Setting
+  /// If @a symbol_name is in the symbol table of the DLL a pointer to
+  /// the @a symbol_name is returned.  Otherwise, returns 0.  Setting
   /// ignore_errors = 1 allows you to probe a dll without generating
   /// error messages in the log.  Handy for determining the capabilities
   /// of a library.
@@ -97,15 +98,15 @@ public:
   ACE_TCHAR *error (void) const;
 
   /**
-   * Return the handle to the caller.  If <become_owner> is non-0 then
-   * caller assumes ownership of the handle and the <ACE_DLL> object
-   * won't call <close> when it goes out of scope, even if
-   * <close_on_destruction> is set.  
+   * Return the handle to the caller.  If @a become_owner is non-0 then
+   * caller assumes ownership of the handle and the ACE_DLL object
+   * won't call close() when it goes out of scope, even if
+   * <close_on_destruction> is set.
    */
   ACE_SHLIB_HANDLE get_handle (int become_owner = 0) const;
 
-  /// Set the handle for the DLL object. By default, the <close> operation on the
-  /// object will be invoked before it is destroyed.
+  /// Set the handle for the DLL object. By default, the close() operation on
+  /// the object will be invoked before it is destroyed.
   int set_handle (ACE_SHLIB_HANDLE handle, int close_on_destruction = 1);
 
 private:
diff --git a/ace/Singleton.h b/ace/Singleton.h
index 81316f731ec..4f976f9d285 100644
--- a/ace/Singleton.h
+++ b/ace/Singleton.h
@@ -8,11 +8,11 @@
  *
  *  @brief
  *
- *  @author Tim Harrison <harrison@cs.wustl.edu>,
- *  Douglas C. Schmidt <schmidt@cs.wustl.edu>,
- *  Chris Lahey,
- *  Rich Christy, and
- *  David Levine <levine@cs.wustl.edu>.
+ *  @author Tim Harrison <harrison@cs.wustl.edu>
+ *  @author Douglas C. Schmidt <schmidt@cs.wustl.edu>
+ *  @author Chris Lahey
+ *  @author Rich Christy
+ *  @author David Levine <levine@cs.wustl.edu>
  */
 //=============================================================================
 
@@ -38,10 +38,10 @@
  * Singleton pattern.  In particular, a single
  * <ACE_Singleton<TYPE, ACE_LOCK> > instance is allocated here,
  * not a <TYPE> instance.  The reason for this is to allow
- * registration with the <ACE_Object_Manager>, so that the
+ * registration with the ACE_Object_Manager, so that the
  * Singleton can be cleaned up when the process exits.  For this
- * scheme to work, a (static) <cleanup> function must be
- * provided.  <ACE_Singleton> provides one so that TYPE doesn't
+ * scheme to work, a (static) cleanup() function must be
+ * provided.  ACE_Singleton provides one so that TYPE doesn't
  * need to.
  * If you want to make sure that only the singleton instance of
  * <T> is created, and that users cannot create their own
@@ -80,7 +80,7 @@ public:
   static TYPE *instance (void);
 
   /// Cleanup method, used by <ace_cleanup_destroyer> to destroy the
-  /// <ACE_Singleton>.
+  /// ACE_Singleton.
   virtual void cleanup (void *param = 0);
 
   /// Dump the state of the object.
@@ -105,15 +105,15 @@ protected:
 /**
  * @class ACE_Unmanaged_Singleton
  *
- * @brief Same as <ACE_Singleton>, except does _not_ register with
- * <ACE_Object_Manager> for destruction.
+ * @brief Same as ACE_Singleton, except does _not_ register with
+ * ACE_Object_Manager for destruction.
  *
- * This version of <ACE_Singleton> can be used if, for example,
- * its DLL will be unloaded before the <ACE_Object_Manager>
- * destroys the instance.  Unlike with <ACE_Singleton>, the
+ * This version of ACE_Singleton can be used if, for example,
+ * its DLL will be unloaded before the ACE_Object_Manager
+ * destroys the instance.  Unlike with ACE_Singleton, the
  * application is responsible for explicitly destroying the
  * instance after it is no longer needed (if it wants to avoid
- * memory leaks, at least).  The <close> static member function
+ * memory leaks, at least).  The close() static member function
  * must be used to explicitly destroy the Singleton.
  * Usage is the same as for ACE_Singleton, but note that if you
  * you declare a friend, the friend class must still be an
@@ -157,17 +157,17 @@ protected:
  * LOCK> > instance is allocated here, not a <TYPE> instance.
  * Each call to the <instance> static method returns a Singleton
  * whose pointer resides in thread-specific storage.  As with
- * <ACE_Singleton>, we use the <ACE_Object_Manager> so that the
+ * ACE_Singleton, we use the ACE_Object_Manager so that the
  * Singleton can be cleaned up when the process exits.  For this
- * scheme to work, a (static) <cleanup> function must be
- * provided.  <ACE_Singleton> provides one so that TYPE doesn't
+ * scheme to work, a (static) cleanup() function must be
+ * provided.  ACE_Singleton provides one so that TYPE doesn't
  * need to.
  */
 template <class TYPE, class ACE_LOCK>
 class ACE_TSS_Singleton : public ACE_Cleanup
 {
 public:
-  /// Global access point to the Singleton.
+  /// Global access point to the singleton.
   static TYPE *instance (void);
 
   /// Cleanup method, used by <ace_cleanup_destroyer> to destroy the
@@ -199,26 +199,24 @@ protected:
 /**
  * @class ACE_Unmanaged_TSS_Singleton
  *
- * @brief Same as <ACE_TSS_Singleton>, except does _not_ register with
- * <ACE_Object_Manager> for destruction.
+ * @brief Same as ACE_TSS_Singleton, except does _not_ register with
+ * ACE_Object_Manager for destruction.
  *
- * This version of <ACE_TSS_Singleton> can be used if, for
- * example, its DLL will be unloaded before the
- * <ACE_Object_Manager> destroys the instance.  Unlike with
- * <ACE_Singleton>, the application is responsible for
- * explicitly destroying the instance after it is no longer
- * needed (if it wants to avoid memory leaks, at least).  The
- * <close> static member function must be used to explicitly
+ * This version of ACE_TSS_Singleton can be used if, for example, its DLL will
+ * be unloaded before the ACE_Object_Manager destroys the instance.  Unlike with
+ * ACE_Singleton, the application is responsible for explicitly destroying the
+ * instance after it is no longer needed (if it wants to avoid memory leaks,
+ * at least).  The close() static member function must be used to explicitly
  * destroy the Singleton.
  */
 template <class TYPE, class ACE_LOCK>
 class ACE_Unmanaged_TSS_Singleton : public ACE_TSS_Singleton <TYPE, ACE_LOCK>
 {
 public:
-  /// Global access point to the Singleton.
+  /// Global access point to the singleton.
   static TYPE *instance (void);
 
-  /// Explicitly delete the Singleton instance.
+  /// Explicitly delete the singleton instance.
   static void close (void);
 
   /// Dump the state of the object.
@@ -240,24 +238,24 @@ protected:
 /**
  * @class ACE_DLL_Singleton_T
  *
- * @brief Same as <ACE_Singleton>, except that it registers for
- * destruction with the <ACE_Framework_Repository> instead of 
- * with the <ACE_Object_Manager> directly.
+ * @brief Same as ACE_Singleton, except that it registers for
+ * destruction with the ACE_Framework_Repository instead of
+ * with the ACE_Object_Manager directly.
  *
- * This version of <ACE_Singleton> should be used for singletons
+ * This version of ACE_Singleton should be used for singletons
  * that live in a dll loaded either directly by ACE_DLL or indirectly
  * by the ACE Service Configuration framework.  Whenever ACE_DLL is ready
  * to actually unload the dll, ACE_DLL_Singleton based dlls associated
  * with that dll will be destroyed first.  In fact, any singleton can
- * safely use ACE_DLL_Singleton, even those that don't live in dlls.  In 
+ * safely use ACE_DLL_Singleton, even those that don't live in dlls.  In
  * that case, the singleton will be destroyed at normal program shutdown.
  *
  * The only additional requirement is that the contained class
- * export name() and dll_name() methods.  See <ACE_DLL_Singleton_Adapter_T>
+ * export name() and dll_name() methods.  See ACE_DLL_Singleton_Adapter_T
  * below for a convenient example of how to satisfy this
  * requirement for the dll_name().
  *
- * Usage is the same as for <ACE_Singleton>, but note that if you
+ * Usage is the same as for ACE_Singleton, but note that if you
  * you declare a friend, the friend class must still be an
  * *ACE_Singleton*<T, [ACE_LOCK]>, not an ACE_Unmanaged_Singleton.
  */
@@ -279,7 +277,7 @@ public:
   static void dump (void);
 
   const ACE_TCHAR *dll_name (void);
- 
+
   const ACE_TCHAR *name (void);
 
 protected:
@@ -297,7 +295,7 @@ protected:
   static ACE_DLL_Singleton_T<TYPE, ACE_LOCK> *singleton_;
 #endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
 
-  /// Get pointer to the Singleton instance.
+  /// Get pointer to the singleton instance.
   static ACE_DLL_Singleton_T<TYPE, ACE_LOCK> *&instance_i (void);
 };