00001 /* -*- C++ -*- */ 00002 // $Id: Process_Mutex.inl,v 1.1.1.1 2001/12/04 14:33:07 chad Exp $ 00003 00004 #if !defined (_ACE_USE_SV_SEM) 00005 ACE_INLINE const ACE_mutex_t & 00006 ACE_Process_Mutex::lock (void) const 00007 { 00008 // ACE_TRACE ("ACE_Process_Mutex::lock"); 00009 return this->lock_.lock (); 00010 } 00011 #endif /* !_ACE_USE_SV_SEM */ 00012 00013 // Explicitly destroy the mutex. 00014 ACE_INLINE int 00015 ACE_Process_Mutex::remove (void) 00016 { 00017 return this->lock_.remove (); 00018 } 00019 00020 // Acquire lock ownership (wait on priority queue if necessary). 00021 ACE_INLINE int 00022 ACE_Process_Mutex::acquire (void) 00023 { 00024 return this->lock_.acquire (); 00025 } 00026 00027 // Acquire lock ownership (wait on priority queue if necessary). 00028 ACE_INLINE int 00029 ACE_Process_Mutex::acquire (ACE_Time_Value &tv) 00030 { 00031 #if !defined (_ACE_USE_SV_SEM) 00032 return this->lock_.acquire (tv); 00033 #else 00034 ACE_UNUSED_ARG (tv); 00035 ACE_NOTSUP_RETURN (-1); 00036 #endif /* !_ACE_USE_SV_SEM */ 00037 } 00038 00039 // Conditionally acquire lock (i.e., don't wait on queue). 00040 ACE_INLINE int 00041 ACE_Process_Mutex::tryacquire (void) 00042 { 00043 return this->lock_.tryacquire (); 00044 } 00045 00046 // Release lock and unblock a thread at head of priority queue. 00047 ACE_INLINE int 00048 ACE_Process_Mutex::release (void) 00049 { 00050 return this->lock_.release (); 00051 } 00052 00053 // Acquire lock ownership (wait on priority queue if necessary). 00054 ACE_INLINE int 00055 ACE_Process_Mutex::acquire_read (void) 00056 { 00057 return this->lock_.acquire_read (); 00058 } 00059 00060 // Acquire lock ownership (wait on priority queue if necessary). 00061 ACE_INLINE int 00062 ACE_Process_Mutex::acquire_write (void) 00063 { 00064 return this->lock_.acquire_write (); 00065 } 00066 00067 // Conditionally acquire a lock (i.e., won't block). 00068 ACE_INLINE int 00069 ACE_Process_Mutex::tryacquire_read (void) 00070 { 00071 return this->lock_.tryacquire_read (); 00072 } 00073 00074 // Conditionally acquire a lock (i.e., won't block). 00075 ACE_INLINE int 00076 ACE_Process_Mutex::tryacquire_write (void) 00077 { 00078 return this->lock_.tryacquire_write (); 00079 } 00080 00081 ACE_INLINE int 00082 ACE_Process_Mutex::tryacquire_write_upgrade (void) 00083 { 00084 return 0; 00085 }
1.2.14 written by Dimitri van Heesch,
© 1997-2002