lock.h revision ab3d9c17d039446a2820517e3f0850f65d5a727f
/** @file
* IPRT - Classes for Scope-based Locking.
*/
/*
* Copyright (C) 2007-2011 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_cpp_lock C++ Scope-based Locking
* @ingroup grp_rt_cpp
* @{
*/
/**
* The mutex lock.
*
* This is used as an 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 RTCLock.
*/
{
{
#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
}
~RTCLockMtx()
{
}
/* lock() and unlock() are private so that only friend RTCLock 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
* RTCLockMtx and to not forget releasing it. To request a RTCLockMtx, simply
* create an instance of RTCLock on the stack and pass the mutex to it:
*
* @code
extern RTCLockMtx gMtx; // wherever this is
...
if (...)
{
RTCLock lock(gMtx);
... // do stuff
// when lock goes out of scope, destructor releases the mutex
}
@endcode
*
* You can also explicitly release the mutex by calling RTCLock::release().
* This might be helpful if the lock doesn't go out of scope early enough
* for your mutex to be released.
*/
{
/** Reference to the lock we're holding. */
/** Whether we're currently holding the lock of if it was already
* explictily released by the release() method. */
bool m_fLocked;
{
m_fLocked = true;
}
~RTCLock()
{
if (m_fLocked)
}
inline void release()
{
if (m_fLocked)
{
m_fLocked = false;
}
}
};
/** @} */
#endif