ACE/ace/Functor.inl

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    Functor.inl
   6  *
   7  *  Inlinable method definitions for non-templatized classes
   8  *  and template specializations implementing the GOF Command Pattern,
   9  *  and STL-style functors.
  10  *
  11  *  @author Chris Gill           <cdgill@cs.wustl.edu>
  12  *
  13  * Based on Command Pattern implementations originally done by
  14  *
  15  * Carlos O'Ryan        <coryan@cs.wustl.edu>
  16  * Douglas C. Schmidt   <d.schmidt@vanderbilt.edu>
  17  * Sergio Flores-Gaitan <sergio@cs.wustl.edu>
  18  *
  19  * and on STL-style functor implementations originally done by
  20  * Irfan Pyarali  <irfan@cs.wustl.edu>
  21  */
  22 //=============================================================================
  23
  24
  25 #include "ace/ACE.h"
  26 #include "ace/OS_NS_string.h"
  27
  28 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  29
  30 //////////////////////////////////////////////////////////////
  31 // GOF Command Pattern Classes and Template Specializations //
  32 //////////////////////////////////////////////////////////////
  33
  34 // Default constructor.
  35
  36 ACE_INLINE
  37 ACE_Command_Base::ACE_Command_Base ()
  38 {
  39 }
  40
  41 ////////////////////////////////////////////////////////////
  42 // STL-style Functor Classes and Template Specializations //
  43 ////////////////////////////////////////////////////////////
  44
  45 ACE_INLINE unsigned long
  46 ACE_Hash<char>::operator () (char t) const
  47 {
  48   return t;
  49 }
  50
  51 #if defined (ACE_HAS_WCHAR) && ! defined (ACE_LACKS_NATIVE_WCHAR_T)
  52 ACE_INLINE unsigned long
  53 ACE_Hash<wchar_t>::operator () (wchar_t t) const
  54 {
  55   return t;
  56 }
  57 #endif /* ACE_HAS_WCHAR && ! ACE_LACKS_NATIVE_WCHAR_T */
  58
  59 ACE_INLINE unsigned long
  60 ACE_Hash<signed char>::operator () (signed char t) const
  61 {
  62   return t;
  63 }
  64
  65 ACE_INLINE unsigned long
  66 ACE_Hash<unsigned char>::operator () (unsigned char t) const
  67 {
  68   return t;
  69 }
  70
  71 ACE_INLINE unsigned long
  72 ACE_Hash<short>::operator () (short t) const
  73 {
  74   return static_cast<unsigned long> (t);
  75 }
  76
  77 ACE_INLINE unsigned long
  78 ACE_Hash<unsigned short>::operator () (unsigned short t) const
  79 {
  80   return static_cast<unsigned long> (t);
  81 }
  82
  83 ACE_INLINE unsigned long
  84 ACE_Hash<int>::operator () (int t) const
  85 {
  86   return static_cast<unsigned long> (t);
  87 }
  88
  89 ACE_INLINE unsigned long
  90 ACE_Hash<unsigned int>::operator () (unsigned int t) const
  91 {
  92   return static_cast<unsigned long> (t);
  93 }
  94
  95 ACE_INLINE unsigned long
  96 ACE_Hash<long>::operator () (long t) const
  97 {
  98   return static_cast<unsigned long> (t);
  99 }
 100
 101 ACE_INLINE unsigned long
 102 ACE_Hash<unsigned long>::operator () (unsigned long t) const
 103 {
 104   return t;
 105 }
 106
 107 #if (ACE_SIZEOF_LONG == 8)
 108 ACE_INLINE unsigned long
 109 ACE_Hash<long long>::operator () (long long t) const
 110 {
 111   return static_cast<unsigned long> (t);
 112 }
 113 #endif /* ACE_SIZEOF_LONG == 8 */
 114
 115 #if (ACE_SIZEOF_LONG == 8)
 116 ACE_INLINE unsigned long
 117 ACE_Hash<unsigned long long>::operator () (unsigned long long t) const
 118 {
 119   return static_cast<unsigned long> (t);
 120 }
 121 #endif /* ACE_SIZEOF_LONG == 8 */
 122
 123 // This #if needs to match the one in Functor.h
 124 #if (ACE_SIZEOF_LONG < 8)
 125 ACE_INLINE unsigned long
 126 ACE_Hash<ACE_INT64>::operator () (ACE_INT64 t) const
 127 {
 128   return static_cast<unsigned long> (t);
 129 }
 130 #endif /* ACE_SIZEOF_LONG < 8 */
 131
 132 #if (ACE_SIZEOF_LONG < 8)
 133 ACE_INLINE unsigned long
 134 ACE_Hash<ACE_UINT64>::operator () (const ACE_UINT64 &t) const
 135 {
 136 #if (ACE_SIZEOF_LONG == 4)
 137   return ACE_U64_TO_U32 (t);
 138 #else
 139   return static_cast<unsigned long> (t);
 140 #endif /* ACE_SIZEOF_LONG */
 141 }
 142 #endif /* ACE_SIZEOF_LONG < 8 */
 143
 144 ACE_INLINE unsigned long
 145 ACE_Hash<const char *>::operator () (const char *t) const
 146 {
 147   return ACE::hash_pjw (t);
 148 }
 149
 150 ACE_INLINE unsigned long
 151 ACE_Hash<char *>::operator () (const char *t) const
 152 {
 153   return ACE::hash_pjw (t);
 154 }
 155
 156 ACE_INLINE unsigned long
 157 ACE_Hash<void *>::operator () (const void *t) const
 158 {
 159   return static_cast<unsigned long> (reinterpret_cast<uintptr_t> (t));
 160 }
 161
 162 /***********************************************************************/
 163 ACE_INLINE int
 164 ACE_Equal_To<const char *>::operator () (const char *lhs, const char *rhs) const
 165 {
 166   return !ACE_OS::strcmp (lhs, rhs);
 167 }
 168
 169 ACE_INLINE int
 170 ACE_Equal_To<char *>::operator () (const char *lhs, const char *rhs) const
 171 {
 172   return !ACE_OS::strcmp (lhs, rhs);
 173 }
 174
 175 ACE_INLINE int
 176 ACE_Equal_To<ACE_UINT16>::operator () (const ACE_UINT16 lhs, const ACE_UINT16 rhs) const
 177 {
 178   return (lhs == rhs);
 179 }
 180
 181 ACE_INLINE int
 182 ACE_Equal_To<ACE_INT16>::operator () (const ACE_INT16 lhs, const ACE_INT16 rhs) const
 183 {
 184   return (lhs == rhs);
 185 }
 186
 187 ACE_INLINE int
 188 ACE_Equal_To<ACE_UINT32>::operator () (const ACE_UINT32 lhs, const ACE_UINT32 rhs) const
 189 {
 190   return (lhs == rhs);
 191 }
 192
 193 ACE_INLINE int
 194 ACE_Equal_To<ACE_INT32>::operator () (const ACE_INT32 lhs, const ACE_INT32 rhs) const
 195 {
 196   return (lhs == rhs);
 197 }
 198
 199 ACE_INLINE int
 200 ACE_Equal_To<ACE_UINT64>::operator () (const ACE_UINT64 lhs, const ACE_UINT64 rhs) const
 201 {
 202   return (lhs == rhs);
 203 }
 204
 205 /****************************************************************************/
 206 ACE_INLINE int
 207 ACE_Less_Than<const char *>::operator () (const char *lhs, const char *rhs) const
 208 {
 209   return (ACE_OS::strcmp (lhs, rhs) < 0) ? 1 : 0;
 210 }
 211
 212 ACE_INLINE int
 213 ACE_Less_Than<char *>::operator () (const char *lhs, const char *rhs) const
 214 {
 215   return (ACE_OS::strcmp (lhs, rhs) < 0) ? 1 : 0;
 216 }
 217
 218
 219 #if defined (ACE_HAS_WCHAR)
 220
 221 ACE_INLINE unsigned long
 222 ACE_Hash<const wchar_t *>::operator () (const wchar_t *t) const
 223 {
 224   return ACE::hash_pjw (t);
 225 }
 226
 227 ACE_INLINE unsigned long
 228 ACE_Hash<wchar_t *>::operator () (const wchar_t *t) const
 229 {
 230   return ACE::hash_pjw (t);
 231 }
 232
 233 ACE_INLINE int
 234 ACE_Equal_To<const wchar_t *>::operator () (const wchar_t *lhs,
 235                                             const wchar_t *rhs) const
 236 {
 237   return !ACE_OS::strcmp (lhs, rhs);
 238 }
 239
 240 ACE_INLINE int
 241 ACE_Equal_To<wchar_t *>::operator () (const wchar_t *lhs,
 242                                       const wchar_t *rhs) const
 243 {
 244   return !ACE_OS::strcmp (lhs, rhs);
 245 }
 246
 247 ACE_INLINE int
 248 ACE_Less_Than<const wchar_t *>::operator () (const wchar_t *lhs, const wchar_t *rhs) const
 249 {
 250   return (ACE_OS::strcmp (lhs, rhs) < 0) ? 1 : 0;
 251 }
 252
 253 ACE_INLINE int
 254 ACE_Less_Than<wchar_t *>::operator () (const wchar_t *lhs, const wchar_t *rhs) const
 255 {
 256   return (ACE_OS::strcmp (lhs, rhs) < 0) ? 1 : 0;
 257 }
 258
 259 #endif  // ACE_HAS_WCHAR
 260
 261 ACE_END_VERSIONED_NAMESPACE_DECL