开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
ncbimtx.inl
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：9k
源码类别：

生物技术

开发平台：

C/C++

ncbimtx.inl：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: ncbimtx.inl,v $
  4.  * PRODUCTION Revision 1000.0  2003/10/29 15:04:49  gouriano
  5.  * PRODUCTION PRODUCTION: IMPORTED [ORIGINAL] Dev-tree R1.5
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. #if defined(CORELIB___NCBIMTX__HPP)  &&  !defined(CORELIB___NCBIMTX__INL)
  11. #define CORELIB___NCBIMTX__INL
  13. /*  $Id: ncbimtx.inl,v 1000.0 2003/10/29 15:04:49 gouriano Exp $
  14.  * ===========================================================================
  15.  *
  16.  *                            PUBLIC DOMAIN NOTICE
  17.  *               National Center for Biotechnology Information
  18.  *
  19.  *  This software/database is a "United States Government Work" under the
  20.  *  terms of the United States Copyright Act.  It was written as part of
  21.  *  the author's official duties as a United States Government employee and
  22.  *  thus cannot be copyrighted.  This software/database is freely available
  23.  *  to the public for use. The National Library of Medicine and the U.S.
  24.  *  Government have not placed any restriction on its use or reproduction.
  25.  *
  26.  *  Although all reasonable efforts have been taken to ensure the accuracy
  27.  *  and reliability of the software and data, the NLM and the U.S.
  28.  *  Government do not and cannot warrant the performance or results that
  29.  *  may be obtained by using this software or data. The NLM and the U.S.
  30.  *  Government disclaim all warranties, express or implied, including
  31.  *  warranties of performance, merchantability or fitness for any particular
  32.  *  purpose.
  33.  *
  34.  *  Please cite the author in any work or product based on this material.
  35.  *
  36.  * ===========================================================================
  37.  *
  38.  * Author: Eugene Vasilchenko
  39.  *
  40.  * File Description:
  41.  *   Mutex classes' inline functions
  42.  *
  43.  */
  45. /////////////////////////////////////////////////////////////////////////////
  46. //  SSystemFastMutexStruct
  47. //
  49. inline
  50. bool SSystemFastMutex::IsInitialized(void) const
  51. {
  52.     return m_Magic == eMutexInitialized;
  53. }
  55. inline
  56. bool SSystemFastMutex::IsUninitialized(void) const
  57. {
  58.     return m_Magic == eMutexUninitialized;
  59. }
  61. inline
  62. void SSystemFastMutex::CheckInitialized(void) const
  63. {
  64. #if defined(INTERNAL_MUTEX_DEBUG)
  65.     if ( !IsInitialized() ) {
  66.         ThrowUninitialized();
  67.     }
  68. #endif
  69. }
  71. inline
  72. void SSystemFastMutex::Lock(void)
  73. {
  74. #if defined(NCBI_NO_THREADS)
  75.     return;
  76. #else
  77.     // check
  78.     CheckInitialized();
  80.     // Acquire system mutex
  81. #  if defined(NCBI_WIN32_THREADS)
  82.     if (WaitForSingleObject(m_Handle, INFINITE) != WAIT_OBJECT_0) {
  83.         ThrowLockFailed();
  84.     }
  85. #  elif defined(NCBI_POSIX_THREADS)
  86.     if ( pthread_mutex_lock(&m_Handle) != 0 ) { // error
  87.         ThrowLockFailed();
  88.     }
  89. #  endif
  90. #endif
  91. }
  93. inline
  94. bool SSystemFastMutex::TryLock(void)
  95. {
  96. #if defined(NCBI_NO_THREADS)
  97.     return true;
  98. #else
  99.     // check
  100.     CheckInitialized();
  102.     // Check if the system mutex is acquired.
  103.     // If not, acquire for the current thread.
  104. #  if defined(NCBI_WIN32_THREADS)
  105.     DWORD status = WaitForSingleObject(m_Handle, 0);
  106.     if (status == WAIT_OBJECT_0) { // ok
  107.         return true;
  108.     }
  109.     else {
  110.         if (status != WAIT_TIMEOUT) { // error
  111.             ThrowTryLockFailed();
  112.         }
  113.         return false;
  114.     }
  115. #  elif defined(NCBI_POSIX_THREADS)
  116.     int status = pthread_mutex_trylock(&m_Handle);
  117.     if (status == 0) { // ok
  118.         return true;
  119.     }
  120.     else {
  121.         if (status != EBUSY) { // error
  122.             ThrowTryLockFailed();
  123.         }
  124.         return false;
  125.     }
  126. #  endif
  127. #endif
  128. }
  130. inline
  131. void SSystemFastMutex::Unlock(void)
  132. {
  133. #if defined(NCBI_NO_THREADS)
  134.     return;
  135. #else
  136.     // check
  137.     CheckInitialized();
  138.         
  139.     // Release system mutex
  140. # if defined(NCBI_WIN32_THREADS)
  141.     if ( !ReleaseMutex(m_Handle) ) { // error
  142.         ThrowUnlockFailed();
  143.     }
  144. # elif defined(NCBI_POSIX_THREADS)
  145.     if ( pthread_mutex_unlock(&m_Handle) != 0 ) { // error
  146.         ThrowUnlockFailed();
  147.     }
  148. # endif
  149. #endif
  150. }
  152. /////////////////////////////////////////////////////////////////////////////
  153. //  SSystemMutex
  154. //
  156. inline
  157. bool SSystemMutex::IsInitialized(void) const
  158. {
  159.     return m_Mutex.IsInitialized();
  160. }
  162. inline
  163. bool SSystemMutex::IsUninitialized(void) const
  164. {
  165.     return m_Mutex.IsUninitialized();
  166. }
  168. inline
  169. void SSystemMutex::InitializeStatic(void)
  170. {
  171.     m_Mutex.InitializeStatic();
  172. }
  174. inline
  175. void SSystemMutex::InitializeDynamic(void)
  176. {
  177.     m_Mutex.InitializeDynamic();
  178.     m_Count = 0;
  179. }
  181. #if defined(NCBI_NO_THREADS)
  182. // empty version of Lock/Unlock methods for inlining
  183. inline
  184. void SSystemMutex::Lock(void)
  185. {
  186. }
  189. inline
  190. bool SSystemMutex::TryLock(void)
  191. {
  192.     return true;
  193. }
  196. inline
  197. void SSystemMutex::Unlock(void)
  198. {
  199. }
  200. #endif
  202. #if defined(NEED_AUTO_INITIALIZE_MUTEX)
  204. inline
  205. CAutoInitializeStaticFastMutex::TObject&
  206. CAutoInitializeStaticFastMutex::Get(void)
  207. {
  208.     if ( !m_Mutex.IsInitialized() ) {
  209.         Initialize();
  210.     }
  211.     return m_Mutex;
  212. }
  214. inline
  215. CAutoInitializeStaticFastMutex::
  216. operator CAutoInitializeStaticFastMutex::TObject&(void)
  217. {
  218.     return Get();
  219. }
  221. inline
  222. void CAutoInitializeStaticFastMutex::Lock(void)
  223. {
  224.     Get().Lock();
  225. }
  227. inline
  228. void CAutoInitializeStaticFastMutex::Unlock(void)
  229. {
  230.     Get().Unlock();
  231. }
  233. inline
  234. bool CAutoInitializeStaticFastMutex::TryLock(void)
  235. {
  236.     return Get().TryLock();
  237. }
  239. inline
  240. CAutoInitializeStaticMutex::TObject&
  241. CAutoInitializeStaticMutex::Get(void)
  242. {
  243.     if ( !m_Mutex.IsInitialized() ) {
  244.         Initialize();
  245.     }
  246.     return m_Mutex;
  247. }
  249. inline
  250. CAutoInitializeStaticMutex::
  251. operator CAutoInitializeStaticMutex::TObject&(void)
  252. {
  253.     return Get();
  254. }
  256. inline
  257. void CAutoInitializeStaticMutex::Lock(void)
  258. {
  259.     Get().Lock();
  260. }
  262. inline
  263. void CAutoInitializeStaticMutex::Unlock(void)
  264. {
  265.     Get().Unlock();
  266. }
  268. inline
  269. bool CAutoInitializeStaticMutex::TryLock(void)
  270. {
  271.     return Get().TryLock();
  272. }
  274. #endif
  276. /////////////////////////////////////////////////////////////////////////////
  277. //  CFastMutex::
  278. //
  280. inline
  281. CFastMutex::CFastMutex(void)
  282. {
  283.     m_Mutex.InitializeDynamic();
  284. }
  286. inline
  287. CFastMutex::~CFastMutex(void)
  288. {
  289.     m_Mutex.Destroy();
  290. }
  292. inline
  293. CFastMutex::operator SSystemFastMutex&(void)
  294. {
  295.     return m_Mutex;
  296. }
  298. inline
  299. void CFastMutex::Lock(void)
  300. {
  301.     m_Mutex.Lock();
  302. }
  304. inline
  305. void CFastMutex::Unlock(void)
  306. {
  307.     m_Mutex.Unlock();
  308. }
  310. inline
  311. bool CFastMutex::TryLock(void)
  312. {
  313.     return m_Mutex.TryLock();
  314. }
  316. // CFastMutexGuard
  318. inline
  319. CFastMutexGuard::CFastMutexGuard(void)
  320.     : m_Mutex(0)
  321. {
  322. }
  324. inline
  325. CFastMutexGuard::CFastMutexGuard(SSystemFastMutex& mtx)
  326.     : m_Mutex(&mtx)
  327. {
  328.     mtx.Lock();
  329. }
  331. inline
  332. CFastMutexGuard::~CFastMutexGuard(void)
  333. {
  334.     if (m_Mutex)
  335.         m_Mutex->Unlock();
  336. }
  338. inline
  339. void CFastMutexGuard::Release(void)
  340. {
  341.     if ( m_Mutex ) {
  342.         m_Mutex->Unlock();
  343.         m_Mutex = 0;
  344.     }
  345. }
  347. inline
  348. void CFastMutexGuard::Guard(SSystemFastMutex& mtx)
  349. {
  350.     if ( &mtx != m_Mutex ) {
  351.         Release();
  352.         mtx.Lock();
  353.         m_Mutex = &mtx;
  354.     }
  355. }
  357. inline
  358. CMutex::CMutex(void)
  359. {
  360.     m_Mutex.InitializeDynamic();
  361. }
  363. inline
  364. CMutex::~CMutex(void)
  365. {
  366.     m_Mutex.Destroy();
  367. }
  369. inline
  370. CMutex::operator SSystemMutex&(void)
  371. {
  372.     return m_Mutex;
  373. }
  375. inline
  376. void CMutex::Lock(void)
  377. {
  378.     m_Mutex.Lock();
  379. }
  381. inline
  382. void CMutex::Unlock(void)
  383. {
  384.     m_Mutex.Unlock();
  385. }
  387. inline
  388. bool CMutex::TryLock(void)
  389. {
  390.     return m_Mutex.TryLock();
  391. }
  393. inline
  394. CMutexGuard::CMutexGuard(void)
  395.     : m_Mutex(0)
  396. {
  397. }
  399. inline
  400. CMutexGuard::CMutexGuard(SSystemMutex& mtx)
  401.     : m_Mutex(&mtx)
  402. {
  403.     mtx.Lock();
  404. }
  406. inline
  407. CMutexGuard::~CMutexGuard(void)
  408. {
  409.     if ( m_Mutex ) {
  410.         m_Mutex->Unlock();
  411.     }
  412. }
  414. inline
  415. void CMutexGuard::Release(void)
  416. {
  417.     if ( m_Mutex ) {
  418.         m_Mutex->Unlock();
  419.         m_Mutex = 0;
  420.     }
  421. }
  423. inline
  424. void CMutexGuard::Guard(SSystemMutex& mtx)
  425. {
  426.     if ( &mtx != m_Mutex ) {
  427.         Release();
  428.         mtx.Lock();
  429.         m_Mutex = &mtx;
  430.     }
  431. }
  433. /*
  434.  * ===========================================================================
  435.  * $Log: ncbimtx.inl,v $
  436.  * Revision 1000.0  2003/10/29 15:04:49  gouriano
  437.  * PRODUCTION: IMPORTED [ORIGINAL] Dev-tree R1.5
  438.  *
  439.  * Revision 1.5  2003/09/02 16:08:48  vasilche
  440.  * Fixed race condition with optimization on some compilers - added 'volatile'.
  441.  * Moved mutex Lock/Unlock methods out of inline section - they are quite complex.
  442.  *
  443.  * Revision 1.4  2003/09/02 15:41:05  ucko
  444.  * Re-sync preprocessor guards with ncbimtx.hpp.
  445.  *
  446.  * Revision 1.3  2003/06/19 19:16:37  vasilche
  447.  * Added CMutexGuard and CFastMutexGuard constructors.
  448.  *
  449.  * Revision 1.2  2002/09/20 20:02:07  vasilche
  450.  * Added public Lock/Unlock/TryLock
  451.  *
  452.  * Revision 1.1  2002/09/19 20:05:41  vasilche
  453.  * Safe initialization of static mutexes
  454.  *
  455.  * ===========================================================================
  456.  */
  458. #endif