00001 // -*- C++ -*- 00002 // 00003 // Thread_Mutex.inl,v 4.2 2005/10/28 23:55:10 ossama Exp 00004 00005 ACE_BEGIN_VERSIONED_NAMESPACE_DECL 00006 00007 ACE_INLINE const ACE_thread_mutex_t & 00008 ACE_Thread_Mutex::lock (void) const 00009 { 00010 // ACE_TRACE ("ACE_Thread_Mutex::lock"); 00011 return this->lock_; 00012 } 00013 00014 ACE_INLINE int 00015 ACE_Thread_Mutex::acquire_read (void) 00016 { 00017 // ACE_TRACE ("ACE_Thread_Mutex::acquire_read"); 00018 return ACE_OS::thread_mutex_lock (&this->lock_); 00019 } 00020 00021 ACE_INLINE int 00022 ACE_Thread_Mutex::acquire_write (void) 00023 { 00024 // ACE_TRACE ("ACE_Thread_Mutex::acquire_write"); 00025 return ACE_OS::thread_mutex_lock (&this->lock_); 00026 } 00027 00028 ACE_INLINE int 00029 ACE_Thread_Mutex::tryacquire_read (void) 00030 { 00031 // ACE_TRACE ("ACE_Thread_Mutex::tryacquire_read"); 00032 return ACE_OS::thread_mutex_trylock (&this->lock_); 00033 } 00034 00035 ACE_INLINE int 00036 ACE_Thread_Mutex::tryacquire_write (void) 00037 { 00038 // ACE_TRACE ("ACE_Thread_Mutex::tryacquire_write"); 00039 return ACE_OS::thread_mutex_trylock (&this->lock_); 00040 } 00041 00042 ACE_INLINE int 00043 ACE_Thread_Mutex::tryacquire_write_upgrade (void) 00044 { 00045 // ACE_TRACE ("ACE_Thread_Mutex::tryacquire_write_upgrade"); 00046 return 0; 00047 } 00048 00049 ACE_INLINE int 00050 ACE_Thread_Mutex::acquire (void) 00051 { 00052 // ACE_TRACE ("ACE_Thread_Mutex::acquire"); 00053 return ACE_OS::thread_mutex_lock (&this->lock_); 00054 } 00055 00056 ACE_INLINE int 00057 ACE_Thread_Mutex::acquire (ACE_Time_Value &tv) 00058 { 00059 // ACE_TRACE ("ACE_Thread_Mutex::acquire"); 00060 return ACE_OS::thread_mutex_lock (&this->lock_, tv); 00061 } 00062 00063 ACE_INLINE int 00064 ACE_Thread_Mutex::acquire (ACE_Time_Value *tv) 00065 { 00066 // ACE_TRACE ("ACE_Thread_Mutex::acquire"); 00067 return ACE_OS::thread_mutex_lock (&this->lock_, tv); 00068 } 00069 00070 ACE_INLINE int 00071 ACE_Thread_Mutex::tryacquire (void) 00072 { 00073 // ACE_TRACE ("ACE_Thread_Mutex::tryacquire"); 00074 return ACE_OS::thread_mutex_trylock (&this->lock_); 00075 } 00076 00077 ACE_INLINE int 00078 ACE_Thread_Mutex::release (void) 00079 { 00080 // ACE_TRACE ("ACE_Thread_Mutex::release"); 00081 return ACE_OS::thread_mutex_unlock (&this->lock_); 00082 } 00083 00084 ACE_INLINE int 00085 ACE_Thread_Mutex::remove (void) 00086 { 00087 // ACE_TRACE ("ACE_Thread_Mutex::remove"); 00088 int result = 0; 00089 if (this->removed_ == 0) 00090 { 00091 this->removed_ = 1; 00092 result = ACE_OS::thread_mutex_destroy (&this->lock_); 00093 } 00094 return result; 00095 } 00096 00097 #if defined (ACE_USES_OBSOLETE_GUARD_CLASSES) 00098 ACE_INLINE int 00099 ACE_Thread_Mutex_Guard::locked (void) 00100 { 00101 // ACE_TRACE ("ACE_Thread_Mutex_Guard::locked"); 00102 return this->owner_ != -1; 00103 } 00104 00105 // Explicitly acquire the lock. 00106 00107 ACE_INLINE int 00108 ACE_Thread_Mutex_Guard::acquire (void) 00109 { 00110 // ACE_TRACE ("ACE_Thread_Mutex_Guard::acquire"); 00111 return this->owner_ = this->lock_.acquire (); 00112 } 00113 00114 // Conditionally acquire the lock (i.e., won't block). 00115 00116 ACE_INLINE int 00117 ACE_Thread_Mutex_Guard::tryacquire (void) 00118 { 00119 // ACE_TRACE ("ACE_Thread_Mutex_Guard::tryacquire"); 00120 return this->owner_ = this->lock_.tryacquire (); 00121 } 00122 00123 // Implicitly and automatically acquire the lock. 00124 00125 ACE_INLINE 00126 ACE_Thread_Mutex_Guard::ACE_Thread_Mutex_Guard (ACE_Thread_Mutex &m, 00127 int block) 00128 : lock_ (m) 00129 { 00130 // ACE_TRACE ("ACE_Thread_Mutex_Guard::ACE_Thread_Mutex_Guard"); 00131 if (block) 00132 this->acquire (); 00133 else 00134 this->tryacquire (); 00135 } 00136 00137 // Explicitly release the lock. 00138 00139 ACE_INLINE int 00140 ACE_Thread_Mutex_Guard::release (void) 00141 { 00142 // ACE_TRACE ("ACE_Thread_Mutex_Guard::release"); 00143 if (this->owner_ != -1) 00144 { 00145 this->owner_ = -1; 00146 return this->lock_.release (); 00147 } 00148 else 00149 return 0; 00150 } 00151 00152 // Implicitly release the lock. 00153 00154 ACE_INLINE 00155 ACE_Thread_Mutex_Guard::~ACE_Thread_Mutex_Guard (void) 00156 { 00157 // ACE_TRACE ("ACE_Thread_Mutex_Guard::~ACE_Thread_Mutex_Guard"); 00158 this->release (); 00159 } 00160 00161 // Explicitly release the lock. 00162 00163 ACE_INLINE int 00164 ACE_Thread_Mutex_Guard::remove (void) 00165 { 00166 // ACE_TRACE ("ACE_Thread_Mutex_Guard::remove"); 00167 this->owner_ = -1; 00168 return this->release (); 00169 } 00170 #endif /* ACE_USES_OBSOLETE_GUARD_CLASSES */ 00171 00172 ACE_END_VERSIONED_NAMESPACE_DECL