epicsGuard.h

Go to the documentation of this file.

/*************************************************************************\
* Copyright (c) 2002 The University of Chicago, as Operator of Argonne
* National Laboratory.
* Copyright (c) 2002 The Regents of the University of California, as
* Operator of Los Alamos National Laboratory.
* SPDX-License-Identifier: EPICS
* EPICS Base is distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution.
\*************************************************************************/
 
#ifndef epicsGuardh
#define epicsGuardh
 
#ifndef assert // allow use of epicsAssert.h
# include <cassert>
#endif
 
/*
 * Author: Jeffrey O. Hill
 */
 
template < class T > class epicsGuardRelease;
 
template < class T >
class epicsGuard {
public:
 typedef epicsGuardRelease<T> release_t;
 
 epicsGuard ( T & mutexIn);
 void assertIdenticalMutex ( const T & ) const;
 ~epicsGuard ();
private:
 T * _pTargetMutex;
 epicsGuard ( const epicsGuard & );
 epicsGuard & operator = ( const epicsGuard & );
 friend class epicsGuardRelease < T >;
};
 
 
template < class T >
class epicsGuardRelease {
public:
 typedef epicsGuard<T> guard_t;
 epicsGuardRelease ( epicsGuard < T > & guardIn);
 ~epicsGuardRelease ();
private:
 epicsGuard < T > & _guard;
 T * _pTargetMutex;
 epicsGuardRelease ( const epicsGuardRelease & );
 epicsGuardRelease & operator = ( const epicsGuardRelease & );
};
 
// same interface as epicsMutex
class epicsMutexNOOP {
public:
 void lock ();
 bool tryLock ();
 void unlock ();
 void show ( unsigned level ) const;
};
 
template < class T >
inline epicsGuard < T > :: epicsGuard ( T & mutexIn ) :
 _pTargetMutex ( & mutexIn )
{
 _pTargetMutex->lock ();
}
 
template < class T >
inline epicsGuard < T > :: ~epicsGuard ()
{
 _pTargetMutex->unlock ();
}
 
template < class T >
inline void epicsGuard < T > :: assertIdenticalMutex (
 const T & mutexToVerify ) const
{
 assert ( _pTargetMutex == & mutexToVerify );
}
 
template < class T >
inline epicsGuardRelease < T > ::
 epicsGuardRelease ( epicsGuard<T> & guardIn ) :
 _guard ( guardIn ),
 _pTargetMutex ( guardIn._pTargetMutex )
{
 // Setting the guard's _pTargetMutex to nill will
 // allow assertIdenticalMutex to catch situations
 // where a guard is being used and it has been
 // released, and also situations where ~epicsGuard ()
 // runs and an epicsGuardRelease is still referencing
 // the guard will be detected.
 _guard._pTargetMutex = 0;
 _pTargetMutex->unlock ();
}
 
template < class T >
inline epicsGuardRelease < T > :: ~epicsGuardRelease ()
{
 _pTargetMutex->lock ();
 _guard._pTargetMutex = _pTargetMutex;
}
 
inline void epicsMutexNOOP::lock () {}
inline bool epicsMutexNOOP::tryLock () { return true; }
inline void epicsMutexNOOP::unlock () {}
inline void epicsMutexNOOP::show ( unsigned ) const {}
 
#endif // epicsGuardh