The Diffraction Grating Calculator

// MSMutex.cpp: implementation for the CMSMutex class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "MSMutex.h"
#include <stdlib.h>
#include <time.h>

// STL includes here

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
 
CMSMutex::CMSMutex()
{
   m_szTheMutexName = _T("AnonymousMutex");
   srand( (unsigned)time( NULL ) );
   CString szRand; szRand.Format(_T("_%6d"),rand());
   m_szTheMutexName += szRand;
   // create and ensure the anonymous mutex, with a random part in the name 
   // (one never knows..., I don't trust windows OS)
   m_hWindowsMutex = ::CreateMutex( NULL, FALSE, m_szTheMutexName.GetBuffer(MAX_PATH) );
   m_szTheMutexName.ReleaseBuffer();
   if( !m_hWindowsMutex )
   {
      NULL;
   }
}

CMSMutex::CMSMutex(const TCHAR* namedMutex)
{
   m_szTheMutexName = namedMutex;
   // create and ensure the named mutex
   m_hWindowsMutex = ::CreateMutex( NULL, FALSE, m_szTheMutexName.GetBuffer(MAX_PATH) );
   m_szTheMutexName.ReleaseBuffer();
   if( !m_hWindowsMutex )
   {
      NULL;
   }
}
 
CMSMutex::~CMSMutex()
{
   // first of all: unlock 
   UnLock();
   // cleanup resources
   ::CloseHandle( m_hWindowsMutex );
   m_hWindowsMutex = NULL;
}

//////////////////////////////////////////////////////////////////////
// Interface
//////////////////////////////////////////////////////////////////////

// LOCK interface

// acquire the resource
int CMSMutex::Acquire(void)
{
   if (Lock())
      return LOCK_ACQUIRED;
   else
      return LOCK_NOT_ACQUIRED;
}

int CMSMutex::Acquire(unsigned long nTimeOut)
{
   if (Lock(nTimeOut))
      return LOCK_ACQUIRED;
   else
      return LOCK_NOT_ACQUIRED;
}

// release the resource
int CMSMutex::Release(void)
{
   if (UnLock(true)) // recursively unlock the mutex
      return LOCK_RELEASED;
   else
      return LOCK_NOT_RELEASED;
}

///////////////////////////////////////////////////////////////////////////////
// Implementation
///////////////////////////////////////////////////////////////////////////////

bool CMSMutex::Lock( void )
{
   // call infinite lock
   return(  Lock( INFINITE ) );
}

bool CMSMutex::Lock( unsigned long nTimeOut /* in milliseconds */ )
{
   // try to get mutex-ownership
   DWORD dwResult = ::WaitForSingleObject( m_hWindowsMutex, (DWORD) nTimeOut );
   // return result
   return( WAIT_OBJECT_0 == dwResult );
}

bool CMSMutex::UnLock( bool bRecurse /* = true */ )
{
   // try unlock
   if( ::ReleaseMutex( m_hWindowsMutex ) )
   {
      // cleanup all locks
      if( bRecurse )
      {
         while( ::ReleaseMutex( m_hWindowsMutex ) );
      }
      // return success
      return( true );
   }
   // return failure
   return( false );
}