lock.h revision e64031e20c39650a7bc902a3e1aba613b9415dee
/** @file
* IPRT - RTLock Classes for Scope-based Locking.
*/
/*
* Copyright (C) 2007 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* The contents of this file may alternatively be used under the terms
* of the Common Development and Distribution License Version 1.0
* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
* VirtualBox OSE distribution, in which case the provisions of the
* CDDL are applicable instead of those of the GPL.
*
* You may elect to license modified versions of this file under the
* terms and conditions of either the GPL or the CDDL or both.
*/
#ifndef ___iprt_cpp_lock_h
#define ___iprt_cpp_lock_h
#include <iprt/critsect.h>
#ifdef RT_LOCK_STRICT
# include <iprt/lockvalidator.h>
#endif
/** @defgroup grp_rt_lock RTLock - Scope-based Locking (C++).
* @ingroup grp_rt
* @{
*/
/**
* The mutex lock.
*
* This is used as a object data member if the intention is to lock
* a single object. This can also be used statically, initialized in
* a global variable, for class wide purposes.
*
* This is best used together with RTLock.
*/
{
{
#ifdef RT_LOCK_STRICT_ORDER
#else
#endif
}
/** Use to when creating locks that belongs in the same "class". */
{
#ifdef RT_LOCK_STRICT_ORDER
#else
#endif
}
~RTLockMtx()
{
}
// lock() and unlock() are private so that only
// friend RTLock can access them
inline void lock()
{
}
inline void unlock()
{
}
};
/**
* The stack object for automatic locking and unlocking.
*
* This is a helper class for automatic locks, to simplify
* requesting a RTLockMtx and to not forget releasing it.
* To request a RTLockMtx, simply create an instance of RTLock
* on the stack and pass the mutex to it:
*
* @code
extern RTLockMtx gMtx; // wherever this is
...
if (...)
{
RTLock lock(gMtx);
... // do stuff
// when lock goes out of scope, destructor releases the mutex
}
@endcode
*
* You can also explicitly release the mutex by calling RTLock::release().
* This might be helpful if the lock doesn't go out of scope early enough
* for your mutex to be released.
*/
{
bool mfLocked;
{
mfLocked = true;
}
~RTLock()
{
if (mfLocked)
}
inline void release()
{
if (mfLocked)
{
mfLocked = false;
}
}
};
/** @} */
#endif