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

1 files changed, 37 insertions, 39 deletions

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);
 };