msclr::lock Class Reference

#include <msclr/lock.h>

Classes
struct	is_not
struct	is_not< T, T >

Public Member Functions
template<class T >
	lock (T^_object)
template<class T >
	lock (T^_object, int _timeout)
template<class T >
	lock (T^_object, System::TimeSpan _timeout)
template<class T >
	lock (T^_object, lock_when)
template<class T >
	lock (gcroot< T^> _object)
template<class T >
	lock (gcroot< T^> _object, int _timeout)
template<class T >
	lock (gcroot< T^> _object, System::TimeSpan _timeout)
template<class T >
	lock (gcroot< T^> _object, lock_when)
	~lock ()
bool	is_locked ()
	operator _detail_class::_safe_bool ()
template<class T >
bool	operator== (T t)
template<class T >
bool	operator!= (T t)
void	acquire (int _timeout)
void	acquire ()
void	acquire (System::TimeSpan _timeout)
bool	try_acquire (int _timeout)
bool	try_acquire (System::TimeSpan _timeout)
void	release ()

Private Attributes
System::Object	m_object
bool	m_locked

Constructor & Destructor Documentation

template<class T >

msclr::lock::lock ( T^  _object )

inline

            : m_object( _object ),
              m_locked( false )
        {
            // ensure that T is not a ReaderWriterLock.
            typedef is_not<T, System::Threading::ReaderWriterLock>::__dont_use_this_type__ _Diagnostic;

            acquire(System::Threading::Timeout::Infinite);
        }

template<class T >

msclr::lock::lock ( T^  _object, int  _timeout  )

inline

            : m_object( _object ),
              m_locked( false )
        {
            // ensure that T is not a ReaderWriterLock.
            typedef is_not<T, System::Threading::ReaderWriterLock>::__dont_use_this_type__ _Diagnostic;

            acquire( _timeout );
        }

template<class T >

msclr::lock::lock ( T^  _object, System::TimeSpan  _timeout  )

inline

            : m_object( _object ),
              m_locked( false )
        {
            // ensure that T is not a ReaderWriterLock.
            typedef is_not<T, System::Threading::ReaderWriterLock>::__dont_use_this_type__ _Diagnostic;

            acquire( _timeout );
        }

template<class T >

msclr::lock::lock ( T^  _object, lock_when    )

inline

            : m_object( _object ),
              m_locked( false )
        {
            // ensure that T is not a ReaderWriterLock.
            typedef is_not<T, System::Threading::ReaderWriterLock>::__dont_use_this_type__ _Diagnostic;
        }

template<class T >

msclr::lock::lock ( gcroot< T^>  _object )

inline

            : m_object( _object ),
              m_locked( false )
        {
            // ensure that T is not a ReaderWriterLock.
            typedef is_not<T, System::Threading::ReaderWriterLock>::__dont_use_this_type__ _Diagnostic;

            acquire(System::Threading::Timeout::Infinite);
        }

template<class T >

msclr::lock::lock ( gcroot< T^>  _object, int  _timeout  )

inline

            : m_object( _object ),
              m_locked( false )
        {
            // ensure that T is not a ReaderWriterLock.
            typedef is_not<T, System::Threading::ReaderWriterLock>::__dont_use_this_type__ _Diagnostic;

            acquire( _timeout );
        }

template<class T >

msclr::lock::lock ( gcroot< T^>  _object, System::TimeSpan  _timeout  )

inline

            : m_object( _object ),
              m_locked( false )
        {
            // ensure that T is not a ReaderWriterLock.
            typedef is_not<T, System::Threading::ReaderWriterLock>::__dont_use_this_type__ _Diagnostic;

            acquire( _timeout );
        }

template<class T >

msclr::lock::lock ( gcroot< T^>  _object, lock_when    )

inline

            : m_object( _object ),
              m_locked( false )
        {
            // ensure that T is not a ReaderWriterLock.
            typedef is_not<T, System::Threading::ReaderWriterLock>::__dont_use_this_type__ _Diagnostic;
        }

msclr::lock::~lock ( )

inline

        {
            release();
        }

Member Function Documentation

void msclr::lock::acquire ( int  _timeout )

inline

        {
            if( ! m_locked )
            {
                System::Threading::Monitor::TryEnter( m_object, _timeout, m_locked );
                if( ! m_locked )
                {
                    static const long _hresult_wait_timeout = 0x80070102;
                    throw System::Runtime::InteropServices::Marshal::GetExceptionForHR( _hresult_wait_timeout );
                }
            }
        }

void msclr::lock::acquire ( )

inline

        {
            if( ! m_locked )
            {
                System::Threading::Monitor::TryEnter( m_object,
                          System::Threading::Timeout::Infinite, m_locked );
                if( ! m_locked )
                {
                    static const long _hresult_wait_timeout = 0x80070102;
                    throw System::Runtime::InteropServices::Marshal::GetExceptionForHR( _hresult_wait_timeout );
                }
            }
        }

void msclr::lock::acquire ( System::TimeSpan  _timeout )

inline

        {
            if( ! m_locked )
            {
                System::Threading::Monitor::TryEnter( m_object, _timeout, m_locked );
                if( ! m_locked )
                {
                    static const long _hresult_wait_timeout = 0x80070102;
                    throw System::Runtime::InteropServices::Marshal::GetExceptionForHR( _hresult_wait_timeout );
                }
            }
        }

bool msclr::lock::is_locked ( )

inline

        {
            return m_locked;
        }

msclr::lock::operator _detail_class::_safe_bool ( )

inline

        {
            return is_locked() ? _detail_class::_safe_true : _detail_class::_safe_false;
        }

template<class T >

bool msclr::lock::operator!= ( T  t )

inline

        {
            // ensure that T is not a _safe_bool.
            typedef is_not<T, _detail_class::_safe_bool>::__dont_use_this_type__ _Diagnostic;

            return m_object != t;
        }

template<class T >

bool msclr::lock::operator== ( T  t )

inline

        {
            // ensure that T is not a _safe_bool.
            typedef is_not<T, _detail_class::_safe_bool>::__dont_use_this_type__ _Diagnostic;

            return m_object == t;
        }

void msclr::lock::release ( )

inline

        {
            if( m_locked )
            {
                System::Threading::Monitor::Exit( m_object );
                m_locked = false;
            }
        }

bool msclr::lock::try_acquire ( int  _timeout )

inline

        {
            if( ! m_locked )
            {
                System::Threading::Monitor::TryEnter( m_object, _timeout, m_locked );
                if( ! m_locked )
                {
                    return false;
                }
            }
            return true;
        }

bool msclr::lock::try_acquire ( System::TimeSpan  _timeout )

inline

        {
            if( ! m_locked )
            {
                System::Threading::Monitor::TryEnter( m_object, _timeout, m_locked );
                if( ! m_locked )
                {
                    return false;
                }
            }
            return true;
        }

Member Data Documentation

bool msclr::lock::m_locked

private

System::Object msclr::lock::m_object

private

---

The documentation for this class was generated from the following file:

• VS2013/inc/msclr/lock.h