Functor, RB_Tree, and pSOS fixes

1 files changed, 303 insertions, 0 deletions

diff --git a/ace/Functor.h b/ace/Functor.h
index 40f58dbca53..55b42143e9b 100644
--- a/ace/Functor.h
+++ b/ace/Functor.h
@@ -10,6 +10,13 @@
 //    Functor.h
 //
 // = DESCRIPTION
+//     Non-templatized classes and class template specializations for 
+//     implementing function objects that are used in  various places 
+//     in ACE.  There are currently two major categories of function
+//     objects in ACE: GOF Command Pattern objects, and STL-style 
+//     functors for comparison of container elements.  The command objects
+//     are invoked via an execute () method, while the STL-style functors are
+//     invoked via an operator() () method.
 //    Non-templatized classes for implementing the GOF Command Pattern,
 //    also known as functors or function objects.
 //
@@ -22,6 +29,10 @@
 //    Douglas C. Schmidt   <schmidt@cs.wustl.edu> and
 //    Sergio Flores-Gaitan <sergio@cs.wustl.edu>
 //
+//    and on STL-style functor implementations originally done by
+//
+//    Irfan Pyarali  <irfan@cs.wustl.edu>
+//
 // ============================================================================
 
 #ifndef ACE_FUNCTOR_H
@@ -33,6 +44,10 @@
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
+//////////////////////////////////////////////////////////////
+// GOF Command Pattern Classes and Template Specializations //
+//////////////////////////////////////////////////////////////
+
 class ACE_Export ACE_Command_Base
 {
   // = TITLE
@@ -59,6 +74,294 @@ public:
   // will never occur.
 };
 
+////////////////////////////////////////////////////////////
+// STL-style Functor Classes and Template Specializations //
+////////////////////////////////////////////////////////////
+
+// Forward declaration since we are going to specialize that template
+// here. The template itself requires this file so every user of the
+// template should also see the specialization.
+template <class TYPE> class ACE_Hash;
+template <class TYPE> class ACE_Equal_To;
+template <class TYPE> class ACE_Less_Than;
+
+class ACE_Export ACE_Hash<char>
+{
+  // = TITLE
+  //     Function object for hashing a char
+public:
+  u_long operator () (char t) const;  
+  // Simply returns t
+};
+
+class ACE_Export ACE_Hash<signed char>
+{
+  // = TITLE
+  //     Function object for hashing a signed char
+public:
+  u_long operator () (signed char t) const;  
+  // Simply returns t
+};
+
+class ACE_Export ACE_Hash<unsigned char>
+{
+  // = TITLE
+  //     Function object for hashing an unsigned char
+public:
+  u_long operator () (unsigned char t) const;  
+  // Simply returns t
+};
+
+class ACE_Export ACE_Hash<short>
+{
+  // = TITLE
+  //     Function object for hashing a short
+public:
+  u_long operator () (short t) const;  
+  // Simply returns t
+};
+
+class ACE_Export ACE_Hash<unsigned short>
+{
+  // = TITLE
+  //     Function object for hashing an unsigned short
+public:
+  u_long operator () (unsigned short t) const;  
+  // Simply returns t
+};
+
+class ACE_Export ACE_Hash<int>
+{
+  // = TITLE
+  //     Function object for hashing an int
+public:
+  u_long operator () (int t) const;  
+  // Simply returns t
+};
+
+class ACE_Export ACE_Hash<unsigned int>
+{
+  // = TITLE
+  //     Function object for hashing an unsigned int
+public:
+  u_long operator () (unsigned int t) const;  
+  // Simply returns t
+};
+
+class ACE_Export ACE_Hash<long>
+{
+  // = TITLE
+  //     Function object for hashing a long 
+public:
+  u_long operator () (long t) const;  
+  // Simply returns t
+};
+
+class ACE_Export ACE_Hash<unsigned long>
+{
+  // = TITLE
+  //     Function object for hashing an unsigned long 
+public:
+  u_long operator () (unsigned long t) const;  
+  // Simply returns t
+};
+
+class ACE_Export ACE_Hash<const char *>
+{
+  // = TITLE
+  //     Function object for hashing a const string
+public:
+  u_long operator () (const char *t) const;  
+  // Calls ACE::hash_pjw
+};
+
+class ACE_Export ACE_Hash<char *>
+{
+  // = TITLE
+  //     Function object for hashing a string
+public:
+  u_long operator () (const char *t) const;  
+  // Calls ACE::hash_pjw
+};
+
+#if !defined (ACE_HAS_WCHAR_TYPEDEFS_CHAR)
+class ACE_Export ACE_Hash<const wchar_t *>
+{
+  // = TITLE
+  //     Function object for hashing a const wide string
+public:
+  u_long operator () (const wchar_t *t) const;  
+  // Calls ACE::hash_pjw
+};
+
+class ACE_Export ACE_Hash<wchar_t *>
+{
+  // = TITLE
+  //     Function object for hashing a wide string
+public:
+  u_long operator () (const wchar_t *t) const;  
+  // Calls ACE::hash_pjw
+};
+#endif /* ! ACE_HAS_WCHAR_TYPEDEFS_CHAR */
+
+#if !defined (ACE_HAS_WCHAR_TYPEDEFS_USHORT)
+class ACE_Export ACE_Hash<const ACE_USHORT16 *>
+{
+  // = TITLE
+  //     Function object for hashing a const wide string
+public:
+  u_long operator () (const ACE_USHORT16 *t) const;  
+  // Calls ACE::hash_pjw
+};
+
+class ACE_Export ACE_Hash<ACE_USHORT16 *>
+{
+  // = TITLE
+  //     Function object for hashing a wide string
+public:
+  u_long operator () (const ACE_USHORT16 *t) const;  
+  // Calls ACE::hash_pjw
+};
+#endif /* ! ACE_HAS_WCHAR_TYPEDEFS_USHORT */
+
+class ACE_Export ACE_Equal_To<const char *>
+{
+  // = TITLE
+  //     Function object for determining whether two const strings are equal.
+public:
+  int operator () (const char *lhs,
+                   const char *rhs) const;  
+  // Simply calls ACE_OS::strcmp
+};
+
+class ACE_Export ACE_Equal_To<char *>
+{
+  // = TITLE
+  //     Function object for determining whether two non-const 
+  //     strings are equal.
+public:
+  int operator () (const char *lhs,
+                   const char *rhs) const;  
+  // Simply calls ACE_OS::strcmp
+};
+
+#if !defined (ACE_HAS_WCHAR_TYPEDEFS_CHAR)
+class ACE_Export ACE_Equal_To<const wchar_t *>
+{
+  // = TITLE
+  //     Function object for determining whether two const wide 
+  //     strings are equal.
+public:
+  int operator () (const wchar_t *lhs,
+                   const wchar_t *rhs) const;  
+  // Simply calls ACE_OS::strcmp
+};
+
+class ACE_Export ACE_Equal_To<wchar_t *>
+{
+  // = TITLE
+  //     Function object for determining whether two wide strings are equal.
+public:
+  int operator () (const wchar_t *lhs,
+                   const wchar_t *rhs) const;  
+  // Simply calls ACE_OS::strcmp
+};
+#endif /* ! ACE_HAS_WCHAR_TYPEDEFS_CHAR */
+
+#if !defined (ACE_HAS_WCHAR_TYPEDEFS_USHORT)
+class ACE_Export ACE_Equal_To<const ACE_USHORT16 *>
+{
+  // = TITLE
+  //     Function object for determining whether two const wide 
+  //     strings are equal.
+public:
+  int operator () (const ACE_USHORT16 *lhs,
+                   const ACE_USHORT16 *rhs) const;  
+  // Simply calls ACE_OS::strcmp
+};
+
+class ACE_Export ACE_Equal_To<ACE_USHORT16 *>
+{
+  // = TITLE
+  //     Function object for determining whether two wide strings are equal.
+public:
+  int operator () (const ACE_USHORT16 *lhs,
+                   const ACE_USHORT16 *rhs) const;  
+  // Simply calls ACE_OS::strcmp
+};
+#endif /* ! ACE_HAS_WCHAR_TYPEDEFS_USHORT */
+
+
+class ACE_Export ACE_Less_Than<const char *>
+{
+  // = TITLE
+  //     Function object for determining whether the first const string
+  //     is less than the second const string.
+public:
+  int operator () (const char *lhs,
+                   const char *rhs) const;  
+  // Simply calls ACE_OS::strcmp
+};
+
+class ACE_Export ACE_Less_Than<char *>
+{
+  // = TITLE
+  //     Function object for determining whether the first string
+  //     is less than the second string.
+public:
+  int operator () (const char *lhs,
+                   const char *rhs) const;  
+  // Simply calls ACE_OS::strcmp
+};
+
+#if !defined (ACE_HAS_WCHAR_TYPEDEFS_CHAR)
+class ACE_Export ACE_Less_Than<const wchar_t *>
+{
+  // = TITLE
+  //     Function object for determining whether the first const wide string
+  //     is less than the second const wide string.
+public:
+  int operator () (const wchar_t *lhs,
+                   const wchar_t *rhs) const;  
+  // Simply calls ACE_OS::strcmp
+};
+
+class ACE_Export ACE_Less_Than<wchar_t *>
+{
+  // = TITLE
+  //     Function object for determining whether the first wide string
+  //     is less than the second wide string.
+public:
+  int operator () (const wchar_t *lhs,
+                   const wchar_t *rhs) const;  
+  // Simply calls ACE_OS::strcmp
+};
+#endif /* ! ACE_HAS_WCHAR_TYPEDEFS_CHAR */
+
+#if !defined (ACE_HAS_WCHAR_TYPEDEFS_USHORT)
+class ACE_Export ACE_Less_Than<const ACE_USHORT16 *>
+{
+  // = TITLE
+  //     Function object for determining whether the first const wide string
+  //     is less than the second const wide string.
+public:
+  int operator () (const ACE_USHORT16 *lhs,
+                   const ACE_USHORT16 *rhs) const;  
+  // Simply calls ACE_OS::strcmp
+};
+
+class ACE_Export ACE_Less_Than<ACE_USHORT16 *>
+{
+  // = TITLE
+  //     Function object for determining whether the first wide string
+  //     is less than the second wide string.
+public:
+  int operator () (const ACE_USHORT16 *lhs,
+                   const ACE_USHORT16 *rhs) const;  
+  // Simply calls ACE_OS::strcmp
+};
+#endif /* ! ACE_HAS_WCHAR_TYPEDEFS_USHORT */
+
 #if defined (__ACE_INLINE__)
 #include "ace/Functor.i"
 #endif /* __ACE_INLINE__ */