ACE/ace/Functor.h

   1 // -*- C++ -*-
   2
   3 //==========================================================================
   4 /**
   5  *  @file    Functor.h
   6  *
   7  *   Non-templatized classes and class template specializations for
   8  *   implementing function objects that are used in  various places
   9  *   in ACE.  There are currently two major categories of function
  10  *   objects in ACE: GoF Command Pattern objects, and STL-style
  11  *   functors for comparison of container elements.  The command objects
  12  *   are invoked via an execute () method, while the STL-style functors are
  13  *   invoked via an operator() () method.
  14  *  Non-templatized classes for implementing the GoF Command Pattern,
  15  *  also known as functors or function objects.
  16  *
  17  *  @author Chris Gill <cdgill@cs.wustl.edu>
  18  *  @author Based on Command Pattern implementations originally done by
  19  *  @author Carlos O'Ryan <coryan@cs.wustl.edu>
  20  *  @author Douglas C. Schmidt <d.schmidt@vanderbilt.edu>
  21  *  @author Sergio Flores-Gaitan <sergio@cs.wustl.edu>
  22  *  @author and on STL-style functor implementations originally done by
  23  *  @author Irfan Pyarali  <irfan@cs.wustl.edu>
  24  */
  25 //==========================================================================
  26
  27
  28 #ifndef ACE_FUNCTOR_H
  29 #define ACE_FUNCTOR_H
  30 #include /**/ "ace/pre.h"
  31
  32 #include /**/ "ace/config-all.h"
  33
  34 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  35 # pragma once
  36 #endif /* ACE_LACKS_PRAGMA_ONCE */
  37
  38 #include /**/ "ace/ACE_export.h"
  39 #include "ace/Basic_Types.h"
  40
  41 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  42
  43 //////////////////////////////////////////////////////////////
  44 // GOF Command Pattern Classes and Template Specializations //
  45 //////////////////////////////////////////////////////////////
  46
  47 /**
  48  * @class ACE_Command_Base
  49  *
  50  * @brief Defines an abstract class that allows us to invoke commands
  51  * without knowing anything about the implementation.
  52  *
  53  * This class declares an interface to execute a command
  54  * independent of the effect of the command, or the objects used
  55  * to implement it.
  56  */
  57 class ACE_Export ACE_Command_Base
  58 {
  59 public:
  60   /// Default constructor.
  61   ACE_Command_Base ();
  62
  63   /// Virtual destructor.
  64   virtual ~ACE_Command_Base () = default;
  65
  66   /**
  67    * Invokes the method encapsulated by the command, passing along the
  68    * passed argument (if any).  Users of classes derived from this
  69    * class must ensure that the resulting invocation can tolerate a
  70    * null void pointer being passed, or otherwise ensure that this
  71    * will never occur.
  72    */
  73   virtual int execute (void *arg = 0) = 0;
  74 };
  75
  76 /**
  77  * @class ACE_Noop_Command
  78  *
  79  * Implements a ACE_Command_Base with an empty execute() body.
  80  */
  81
  82 class ACE_Export ACE_Noop_Command
  83   : public ACE_Command_Base
  84 {
  85 public:
  86   /// Constructor
  87   ACE_Noop_Command() = default;
  88
  89   /// Implement the empty execute() member function
  90   virtual int execute(void*);
  91 };
  92
  93 ////////////////////////////////////////////////////////////
  94 // STL-style Functor Classes and Template Specializations //
  95 ////////////////////////////////////////////////////////////
  96
  97 // Forward declaration since we are going to specialize that template
  98 // here. The template itself requires this file so every user of the
  99 // template should also see the specialization.
 100 template <class TYPE> class ACE_Hash;
 101 template <class TYPE> class ACE_Equal_To;
 102 template <class TYPE> class ACE_Less_Than;
 103
 104 /**
 105  * @brief Function object for hashing a char
 106  */
 107 template<>
 108 class ACE_Export ACE_Hash<char>
 109 {
 110 public:
 111   /// Simply returns t
 112   unsigned long operator () (char t) const;
 113 };
 114
 115 /**
 116  * @brief Function object for hashing a signed char
 117  */
 118 template<>
 119 class ACE_Export ACE_Hash<signed char>
 120 {
 121 public:
 122   /// Simply returns t
 123   unsigned long operator () (signed char t) const;
 124 };
 125
 126 /**
 127  * @brief Function object for hashing an unsigned char
 128  */
 129 template<>
 130 class ACE_Export ACE_Hash<unsigned char>
 131 {
 132 public:
 133   /// Simply returns t
 134   unsigned long operator () (unsigned char t) const;
 135 };
 136
 137 /**
 138  * @brief Function object for hashing a short number
 139  */
 140 template<>
 141 class ACE_Export ACE_Hash<short>
 142 {
 143 public:
 144   /// Simply returns t
 145   unsigned long operator () (short t) const;
 146 };
 147
 148 /**
 149  * @brief Function object for hashing an unsigned short number
 150  */
 151 template<>
 152 class ACE_Export ACE_Hash<unsigned short>
 153 {
 154 public:
 155   /// Simply returns t
 156   unsigned long operator () (unsigned short t) const;
 157 };
 158
 159 /**
 160  * @brief Function object for hashing an int number
 161  */
 162 template<>
 163 class ACE_Export ACE_Hash<int>
 164 {
 165 public:
 166   /// Simply returns t
 167   unsigned long operator () (int t) const;
 168 };
 169
 170 /**
 171  * @brief Function object for hashing an unsigned int number
 172  */
 173 template<>
 174 class ACE_Export ACE_Hash<unsigned int>
 175 {
 176 public:
 177   /// Simply returns t
 178   unsigned long operator () (unsigned int t) const;
 179 };
 180
 181 /**
 182  * @brief Function object for hashing a long number
 183  */
 184 template<>
 185 class ACE_Export ACE_Hash<long>
 186 {
 187 public:
 188   /// Simply returns t
 189   unsigned long operator () (long t) const;
 190 };
 191
 192 /**
 193  * @brief Function object for hashing an unsigned long number
 194  */
 195 template<>
 196 class ACE_Export ACE_Hash<unsigned long>
 197 {
 198 public:
 199   /// Simply returns t
 200   unsigned long operator () (unsigned long t) const;
 201 };
 202
 203 #if (ACE_SIZEOF_LONG == 8)
 204 /**
 205  * @brief Function object for hashing a long long number
 206  */
 207 template<>
 208 class ACE_Export ACE_Hash<long long>
 209 {
 210 public:
 211   /// Simply returns t
 212   unsigned long operator () (long long t) const;
 213 };
 214 #endif /* ACE_SIZEOF_LONG == 8 */
 215
 216 #if (ACE_SIZEOF_LONG == 8)
 217 /**
 218  * @brief Function object for hashing an unsigned long long number
 219  */
 220 template<>
 221 class ACE_Export ACE_Hash<unsigned long long>
 222 {
 223 public:
 224   /// Simply returns t
 225   unsigned long operator () (unsigned long long t) const;
 226 };
 227 #endif /* ACE_SIZEOF_LONG == 8 */
 228
 229 #if (ACE_SIZEOF_LONG < 8)
 230 /**
 231  * @brief Function object for hashing a signed 64-bit number
 232  */
 233 template<>
 234 class ACE_Export ACE_Hash<ACE_INT64>
 235 {
 236 public:
 237   /// Simply returns t
 238   unsigned long operator () (ACE_INT64 t) const;
 239 };
 240 #endif /* ACE_SIZEOF_LONG < 8 */
 241
 242 #if (ACE_SIZEOF_LONG < 8)
 243 /**
 244  * @brief Function object for hashing an unsigned 64-bit number
 245  */
 246 template<>
 247 class ACE_Export ACE_Hash<ACE_UINT64>
 248 {
 249 public:
 250   /// Simply returns t
 251   unsigned long operator () (const ACE_UINT64 &t) const;
 252 };
 253 #endif /* ACE_SIZEOF_LONG < 8 */
 254
 255 /**
 256  * @brief Function object for hashing a const string
 257  */
 258 template<>
 259 class ACE_Export ACE_Hash<const char *>
 260 {
 261 public:
 262   /// Calls ACE::hash_pjw
 263   unsigned long operator () (const char *t) const;
 264 };
 265
 266 /**
 267  * @brief Function object for hashing a string
 268  */
 269 template<>
 270 class ACE_Export ACE_Hash<char *>
 271 {
 272 public:
 273   /// Calls ACE::hash_pjw
 274   unsigned long operator () (const char *t) const;
 275 };
 276
 277 /**
 278  * @brief Function object for hashing a void */
 279 template<>
 280 class ACE_Export ACE_Hash<void *>
 281 {
 282 public:
 283   unsigned long operator () (const void *) const;
 284 };
 285
 286 /**
 287  * @brief Function object for determining whether two const strings are equal.
 288  */
 289 template<>
 290 class ACE_Export ACE_Equal_To<const char *>
 291 {
 292 public:
 293   /// Simply calls ACE_OS::strcmp
 294   int operator () (const char *lhs,
 295                    const char *rhs) const;
 296 };
 297
 298 /**
 299  * @brief Function object for determining whether two non-const
 300  * strings are equal.
 301  */
 302 template<>
 303 class ACE_Export ACE_Equal_To<char *>
 304 {
 305 public:
 306   /// Simply calls ACE_OS::strcmp
 307   int operator () (const char *lhs,
 308                    const char *rhs) const;
 309 };
 310
 311 /**
 312  * @brief Function object for determining whether two unsigned
 313  * 16 bit ints are equal.
 314  */
 315 template<>
 316 class ACE_Export ACE_Equal_To<ACE_UINT16>
 317 {
 318 public:
 319   /// Simply calls built-in operators
 320   int operator () (const ACE_UINT16 lhs,
 321                    const ACE_UINT16 rhs) const;
 322 };
 323
 324 /**
 325  * @brief Function object for determining whether two
 326  * 16 bit ints are equal.
 327  */
 328 template<>
 329 class ACE_Export ACE_Equal_To<ACE_INT16>
 330 {
 331 public:
 332   /// Simply calls built-in operators
 333   int operator () (const ACE_INT16 lhs,
 334                    const ACE_INT16 rhs) const;
 335 };
 336
 337 /**
 338  * @brief Function object for determining whether two unsigned
 339  * 32 bit ints are equal.
 340  */
 341 template<>
 342 class ACE_Export ACE_Equal_To<ACE_UINT32>
 343 {
 344 public:
 345   /// Simply calls built-in operators
 346   int operator () (const ACE_UINT32 lhs,
 347                    const ACE_UINT32 rhs) const;
 348 };
 349
 350 /**
 351  * @brief Function object for determining whether two
 352  * 32 bit ints are equal.
 353  */
 354 template<>
 355 class ACE_Export ACE_Equal_To<ACE_INT32>
 356 {
 357 public:
 358   /// Simply calls built-in operators
 359   int operator () (const ACE_INT32 lhs,
 360                    const ACE_INT32 rhs) const;
 361 };
 362
 363 /**
 364  * @brief Function object for determining whether two unsigned
 365  * 64 bit ints are equal.
 366  */
 367 template<>
 368 class ACE_Export ACE_Equal_To<ACE_UINT64>
 369 {
 370 public:
 371   /// Simply calls built-in operators
 372   int operator () (const ACE_UINT64 lhs,
 373                    const ACE_UINT64 rhs) const;
 374 };
 375
 376 /**
 377  * @brief Function object for determining whether the first const string
 378  * is less than the second const string.
 379  */
 380 template<>
 381 class ACE_Export ACE_Less_Than<const char *>
 382 {
 383 public:
 384   /// Simply calls ACE_OS::strcmp
 385   int operator () (const char *lhs,
 386                    const char *rhs) const;
 387 };
 388
 389 /**
 390  * @brief Function object for determining whether the first string
 391  * is less than the second string.
 392  */
 393 template<>
 394 class ACE_Export ACE_Less_Than<char *>
 395 {
 396 public:
 397   /// Simply calls ACE_OS::strcmp
 398   int operator () (const char *lhs,
 399                    const char *rhs) const;
 400 };
 401
 402 #if defined (ACE_HAS_WCHAR)
 403
 404 #  if ! defined (ACE_LACKS_NATIVE_WCHAR_T)
 405 /**
 406  * @brief Function object for hashing a wchar_t
 407  */
 408 template<>
 409 class ACE_Export ACE_Hash<wchar_t>
 410 {
 411 public:
 412   /// Simply returns t
 413   unsigned long operator () (wchar_t t) const;
 414 };
 415 #  endif /* ACE_LACKS_NATIVE_WCHAR_T */
 416 /**
 417  * @brief Function object for hashing a const string
 418  */
 419 template<>
 420 class ACE_Export ACE_Hash<const wchar_t *>
 421 {
 422 public:
 423   /// Calls ACE::hash_pjw
 424   unsigned long operator () (const wchar_t *t) const;
 425 };
 426
 427 /**
 428  * @brief Function object for hashing a string
 429  */
 430 template<>
 431 class ACE_Export ACE_Hash<wchar_t *>
 432 {
 433 public:
 434   /// Calls ACE::hash_pjw
 435   unsigned long operator () (const wchar_t *t) const;
 436 };
 437
 438 /**
 439  * @brief Function object for determining whether two const strings are equal.
 440  */
 441 template<>
 442 class ACE_Export ACE_Equal_To<const wchar_t *>
 443 {
 444 public:
 445   /// Simply calls ACE_OS::strcmp
 446   int operator () (const wchar_t *lhs,
 447                    const wchar_t *rhs) const;
 448 };
 449
 450 /**
 451  * @brief Function object for determining whether two non-const
 452  * strings are equal.
 453  */
 454 template<>
 455 class ACE_Export ACE_Equal_To<wchar_t *>
 456 {
 457 public:
 458   /// Simply calls ACE_OS::strcmp
 459   int operator () (const wchar_t *lhs,
 460                    const wchar_t *rhs) const;
 461 };
 462
 463 /**
 464  * @brief Function object for determining whether the first const string
 465  * is less than the second const string.
 466  */
 467 template<>
 468 class ACE_Export ACE_Less_Than<const wchar_t *>
 469 {
 470 public:
 471   /// Simply calls ACE_OS::strcmp
 472   int operator () (const wchar_t *lhs,
 473                    const wchar_t *rhs) const;
 474 };
 475
 476 /**
 477  * @brief Function object for determining whether the first string
 478  * is less than the second string.
 479  */
 480 template<>
 481 class ACE_Export ACE_Less_Than<wchar_t *>
 482 {
 483 public:
 484   /// Simply calls ACE_OS::strcmp
 485   int operator () (const wchar_t *lhs,
 486                    const wchar_t *rhs) const;
 487 };
 488
 489 #endif  // ACE_HAS_WCHAR
 490
 491 ACE_END_VERSIONED_NAMESPACE_DECL
 492
 493 #if defined (__ACE_INLINE__)
 494 #include "ace/Functor.inl"
 495 #endif /* __ACE_INLINE__ */
 496
 497 #include /**/ "ace/post.h"
 498 #endif /* ACE_FUNCTOR_H */