ACE/ace/Null_Mutex.h

   1 // -*- C++ -*-
   2
   3 //==========================================================================
   4 /**
   5  *  @file    Null_Mutex.h
   6  *
   7  *   Moved from Synch.h.
   8  *
   9  *  @author Douglas C. Schmidt <d.schmidt@vanderbilt.edu>
  10  */
  11 //==========================================================================
  12
  13 #ifndef ACE_NULL_MUTEX_H
  14 #define ACE_NULL_MUTEX_H
  15 #include /**/ "ace/pre.h"
  16
  17 #include "ace/os_include/os_errno.h"
  18
  19 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  20 # pragma once
  21 #endif /* ACE_LACKS_PRAGMA_ONCE */
  22
  23 #include "ace/Global_Macros.h"
  24 #include "ace/OS_Memory.h"
  25
  26 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  27
  28 class ACE_Time_Value;
  29
  30 /**
  31  * @class ACE_Null_Mutex
  32  *
  33  * @brief Implement a do nothing ACE_Mutex, i.e., all the methods are
  34  * no ops.
  35  */
  36 class ACE_Export ACE_Null_Mutex
  37 {
  38 public:
  39   ACE_Null_Mutex (const ACE_TCHAR * = 0)
  40     : lock_ (0) {}
  41   ~ACE_Null_Mutex (void) {}
  42   /// Return 0.
  43   int remove (void) {return 0;}
  44
  45   /// Return 0.
  46   int acquire (void) {return 0;}
  47
  48   /// Return -1 with @c errno == @c ETIME.
  49   int acquire (ACE_Time_Value &) {errno = ETIME; return -1;}
  50
  51   /// Return -1 with @c errno == @c ETIME.
  52   int acquire (ACE_Time_Value *) {errno = ETIME; return -1;}
  53
  54   /// Return 0.
  55   int tryacquire (void) {return 0;}
  56
  57   /// Return 0.
  58   int release (void) {return 0;}
  59
  60   /// Return 0.
  61   int acquire_write (void) {return 0;}
  62
  63   /// Return 0.
  64   int tryacquire_write (void) {return 0;}
  65
  66   /// Return 0.
  67   int tryacquire_write_upgrade (void) {return 0;}
  68
  69   /// Return 0.
  70   int acquire_read (void) {return 0;}
  71
  72   /// Return 0.
  73   int tryacquire_read (void) {return 0;}
  74
  75   /// Dump the state of an object.
  76   void dump (void) const {}
  77
  78   /// Declare the dynamic allocation hooks.
  79   //ACE_ALLOC_HOOK_DECLARE;
  80
  81   int lock_; // A dummy lock.
  82
  83   ACE_ALLOC_HOOK_DECLARE;
  84 };
  85
  86 // FUZZ: disable check_for_ACE_Guard
  87
  88 template <class ACE_LOCK>
  89 class ACE_Guard;
  90
  91 /**
  92  * @brief Template specialization of ACE_Guard for the
  93  * ACE_Null_Mutex.
  94  *
  95  * This specialization is useful since it helps to speedup
  96  * performance of the "Null_Mutex" considerably.
  97  */
  98 template<>
  99 class ACE_Export ACE_Guard<ACE_Null_Mutex>
 100 {
 101 public:
 102   ACE_Guard (ACE_Null_Mutex &) {}
 103   ACE_Guard (ACE_Null_Mutex &, int) {}
 104   ACE_Guard (ACE_Null_Mutex &, int, int) {}
 105 #if defined (ACE_WIN32)
 106   ~ACE_Guard (void) {}
 107 #endif /* ACE_WIN32 */
 108
 109   int acquire (void) { return 0; }
 110   int tryacquire (void) { return 0; }
 111   int release (void) { return 0; }
 112   void disown (void) {}
 113   int locked (void) { return 1; }
 114   int remove (void) { return 0; }
 115   void dump (void) const {}
 116
 117 private:
 118
 119   // Disallow copying and assignment.
 120   ACE_Guard (const ACE_Guard<ACE_Null_Mutex> &);
 121   void operator= (const ACE_Guard<ACE_Null_Mutex> &);
 122
 123 };
 124
 125 template <class ACE_LOCK>
 126 class ACE_Write_Guard;
 127
 128 /**
 129  * @brief Template specialization of ACE_Write_Guard for the
 130  * ACE_Null_Mutex.
 131  */
 132 template<>
 133 class ACE_Export ACE_Write_Guard<ACE_Null_Mutex>
 134   : public ACE_Guard<ACE_Null_Mutex>
 135 {
 136 public:
 137   ACE_Write_Guard (ACE_Null_Mutex &m)
 138     : ACE_Guard<ACE_Null_Mutex> (m) {}
 139   ACE_Write_Guard (ACE_Null_Mutex &m, int blocked)
 140     : ACE_Guard<ACE_Null_Mutex> (m, blocked) {}
 141
 142   int acquire_write (void) { return 0; }
 143   int acquire (void) { return 0; }
 144   int tryacquire_write (void) { return 0; }
 145   int tryacquire (void) { return 0; }
 146   void dump (void) const {}
 147 };
 148
 149 template <class ACE_LOCK>
 150 class ACE_Read_Guard;
 151
 152 /**
 153  * @brief Template specialization of ACE_Read)Guard for the
 154  * ACE_Null_Mutex.
 155  */
 156 template<>
 157 class ACE_Export ACE_Read_Guard<ACE_Null_Mutex>
 158   : public ACE_Guard<ACE_Null_Mutex>
 159 {
 160 public:
 161   ACE_Read_Guard (ACE_Null_Mutex &m)
 162     : ACE_Guard<ACE_Null_Mutex> (m) {}
 163   ACE_Read_Guard (ACE_Null_Mutex &m, int blocked)
 164     : ACE_Guard<ACE_Null_Mutex> (m, blocked) {}
 165
 166   int acquire_read (void) { return 0; }
 167   int acquire (void) { return 0; }
 168   int tryacquire_read (void) { return 0; }
 169   int tryacquire (void) { return 0; }
 170   void dump (void) const {}
 171 };
 172
 173 // FUZZ: enable check_for_ACE_Guard
 174
 175 template <class T> class ACE_Malloc_Lock_Adapter_T;
 176
 177 /**
 178  * @brief Template specialization of ACE_Malloc_Lock_Adapter_T for the
 179  * ACE_Null_Mutex.
 180  */
 181 template<>
 182 class ACE_Export ACE_Malloc_Lock_Adapter_T<ACE_Null_Mutex>
 183 {
 184 public:
 185   ACE_Null_Mutex * operator () (const ACE_TCHAR *name)
 186   {
 187     ACE_Null_Mutex *p;
 188     ACE_NEW_RETURN (p, ACE_Null_Mutex (name), 0);
 189     return p;
 190   }
 191 };
 192
 193 ACE_END_VERSIONED_NAMESPACE_DECL
 194
 195 #include /**/ "ace/post.h"
 196 #endif /* ACE_NULL_MUTEX_H */