1 files changed, 363 insertions, 0 deletions
diff --git a/ace/Utils/Functor.h b/ace/Utils/Functor.h
new file mode 100644
index 00000000000..5e96d5cbad5
--- /dev/null
+++ b/ace/Utils/Functor.h
@@ -0,0 +1,363 @@
+/* -*- C++ -*- */
+
+//=============================================================================
+/**
+ *  @file    Functor.h
+ *
+ *  $Id$
+ *
+ *   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.
+ *
+ *
+ *  @author Chris Gill <cdgill@cs.wustl.edu>
+ *  @author Based on Command Pattern implementations originally done by
+ *  @author Carlos O'Ryan <coryan@cs.wustl.edu>
+ *  @author Douglas C. Schmidt <schmidt@cs.wustl.edu>
+ *  @author Sergio Flores-Gaitan <sergio@cs.wustl.edu>
+ *  @author and on STL-style functor implementations originally done by
+ *  @author Irfan Pyarali  <irfan@cs.wustl.edu>
+ */
+//=============================================================================
+
+
+#ifndef ACE_FUNCTOR_H
+#define ACE_FUNCTOR_H
+#include "ace/pre.h"
+
+#include "ace/ACE.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+//////////////////////////////////////////////////////////////
+// GOF Command Pattern Classes and Template Specializations //
+//////////////////////////////////////////////////////////////
+
+/**
+ * @class ACE_Command_Base
+ *
+ * @brief Defines an abstract class that allows us to invoke commands
+ * without knowing anything about the implementation.
+ *
+ * This class declares an interface to execute a command
+ * independent of the effect of the command, or the objects used
+ * to implement it.
+ */
+class ACE_Export ACE_Command_Base
+{
+public:
+  // = Initialization and termination methods.
+  /// Default constructor.
+  ACE_Command_Base (void);
+
+  /// Virtaul destructor.
+  virtual ~ACE_Command_Base (void);
+
+  /**
+   * Invokes the method encapsulated by the command, passing along the
+   * passed argument (if any).  Users of classes derived from this
+   * class must ensure that the resulting invocation can tolerate a
+   * null void pointer being passed, or otherwise ensure that this
+   * will never occur.
+   */
+  virtual int execute (void *arg = 0) = 0;
+};
+
+////////////////////////////////////////////////////////////
+// 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;
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Hash<char>
+ *
+ * @brief Function object for hashing a char
+ */
+class ACE_Export ACE_Hash<char>
+{
+public:
+  /// Simply returns t
+  u_long operator () (char t) const;
+};
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Hash<signed
+ *
+ * @brief Function object for hashing a signed char
+ */
+class ACE_Export ACE_Hash<signed char>
+{
+public:
+  /// Simply returns t
+  u_long operator () (signed char t) const;
+};
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Hash<unsigned
+ *
+ * @brief Function object for hashing an unsigned char
+ */
+class ACE_Export ACE_Hash<unsigned char>
+{
+public:
+  /// Simply returns t
+  u_long operator () (unsigned char t) const;
+};
+
+// @@ ADD HASHES FOR ACE TYPES
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Hash<ACE_INT16>
+ *
+ * @brief Function object for hashing a 16-bit signed number
+ */
+class ACE_Export ACE_Hash<ACE_INT16>
+{
+public:
+  /// Simply returns t
+  u_long operator () (ACE_INT16 t) const;
+};
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Hash<ACE_UINT16>
+ *
+ * @brief Function object for hashing a 16-bit unsigned number
+ */
+class ACE_Export ACE_Hash<ACE_UINT16>
+{
+public:
+  /// Simply returns t
+  u_long operator () (ACE_UINT16 t) const;
+};
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Hash<ACE_INT32>
+ *
+ * @brief Function object for hashing a 32-bit signed number
+ */
+class ACE_Export ACE_Hash<ACE_INT32>
+{
+public:
+  /// Simply returns t
+  u_long operator () (ACE_INT32 t) const;
+};
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Hash<ACE_UINT32>
+ *
+ * @brief Function object for hashing a 32-bit unsigned number
+ */
+class ACE_Export ACE_Hash<ACE_UINT32>
+{
+public:
+  /// Simply returns t
+  u_long operator () (ACE_UINT32 t) const;
+};
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Hash<ACE_UINT64>
+ *
+ * @brief Function object for hashing a 64-bit unsigned number
+ */
+class ACE_Export ACE_Hash<ACE_UINT64>
+{
+public:
+  /// Simply returns t
+  u_long operator () (ACE_UINT64 t) const;
+};
+
+// @@ DONE ADDING HASHES FOR ACE TYPES
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Hash<const
+ *
+ * @brief Function object for hashing a const string
+ */
+class ACE_Export ACE_Hash<const ACE_TCHAR *>
+{
+public:
+  /// Calls ACE::hash_pjw
+  u_long operator () (const ACE_TCHAR *t) const;
+};
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Hash<ACE_TCHAR
+ *
+ * @brief Function object for hashing a string
+ */
+class ACE_Export ACE_Hash<ACE_TCHAR *>
+{
+public:
+  /// Calls ACE::hash_pjw
+  u_long operator () (const ACE_TCHAR *t) const;
+};
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Equal_To<const
+ *
+ * @brief Function object for determining whether two const strings are equal.
+ */
+class ACE_Export ACE_Equal_To<const ACE_TCHAR *>
+{
+public:
+  /// Simply calls ACE_OS::strcmp
+  int operator () (const ACE_TCHAR *lhs,
+                   const ACE_TCHAR *rhs) const;
+};
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Equal_To<ACE_TCHAR
+ *
+ * @brief Function object for determining whether two non-const
+ * strings are equal.
+ */
+class ACE_Export ACE_Equal_To<ACE_TCHAR *>
+{
+public:
+  /// Simply calls ACE_OS::strcmp
+  int operator () (const ACE_TCHAR *lhs,
+                   const ACE_TCHAR *rhs) const;
+};
+
+ ACE_TEMPLATE_SPECIALIZATION
+ /**
+ * @class ACE_Equal_To<ACE_UINT16>
+ *
+ * @brief Function object for determining whether two unsigned
+ * 16 bit ints are equal.
+ */
+class ACE_Export ACE_Equal_To<ACE_UINT16>
+{
+public:
+  /// Simply calls built-in operators
+  int operator () (const ACE_UINT16 lhs,
+                   const ACE_UINT16 rhs) const;
+};
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Equal_To<ACE_INT16>
+ *
+ * @brief Function object for determining whether two
+ * 16 bit ints are equal.
+ */
+class ACE_Export ACE_Equal_To<ACE_INT16>
+{
+public:
+  /// Simply calls built-in operators
+  int operator () (const ACE_INT16 lhs,
+                   const ACE_INT16 rhs) const;
+};
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Equal_To<ACE_UINT32>
+ *
+ * @brief Function object for determining whether two unsigned
+ * 32 bit ints are equal.
+ */
+class ACE_Export ACE_Equal_To<ACE_UINT32>
+{
+public:
+  /// Simply calls built-in operators
+  int operator () (const ACE_UINT32 lhs,
+                   const ACE_UINT32 rhs) const;
+};
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Equal_To<ACE_INT32>
+ *
+ * @brief Function object for determining whether two
+ * 32 bit ints are equal.
+ */
+class ACE_Export ACE_Equal_To<ACE_INT32>
+{
+public:
+  /// Simply calls built-in operators
+  int operator () (const ACE_INT32 lhs,
+                   const ACE_INT32 rhs) const;
+};
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Equal_To<ACE_UINT64>
+ *
+ * @brief Function object for determining whether two unsigned
+ * 64 bit ints are equal.
+ */
+class ACE_Export ACE_Equal_To<ACE_UINT64>
+{
+public:
+  /// Simply calls built-in operators
+  int operator () (const ACE_UINT64 lhs,
+                   const ACE_UINT64 rhs) const;
+};
+
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Less_Than<const
+ *
+ * @brief Function object for determining whether the first const string
+ * is less than the second const string.
+ */
+class ACE_Export ACE_Less_Than<const ACE_TCHAR *>
+{
+public:
+  /// Simply calls ACE_OS::strcmp
+  int operator () (const ACE_TCHAR *lhs,
+                   const ACE_TCHAR *rhs) const;
+};
+
+ACE_TEMPLATE_SPECIALIZATION
+/**
+ * @class ACE_Less_Than<ACE_TCHAR
+ *
+ * @brief Function object for determining whether the first string
+ * is less than the second string.
+ */
+class ACE_Export ACE_Less_Than<ACE_TCHAR *>
+{
+public:
+  /// Simply calls ACE_OS::strcmp
+  int operator () (const ACE_TCHAR *lhs,
+                   const ACE_TCHAR *rhs) const;
+};
+
+#if defined (__ACE_INLINE__)
+#include "ace/Functor.i"
+#endif /* __ACE_INLINE__ */
+
+// Include the templates here.
+#include "ace/Functor_T.h"
+
+#include "ace/post.h"
+#endif /* ACE_FUNCTOR_H */