MboLockedVar.h

Go to the documentation of this file.

/*****************************************************************************
* Copyright (c) 2001 - 2008 Marcus Boerger.  All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
* ========================================================================= */

/* ------------------------------------------------------------------------ */
/* Name:      MboLockedVar.h
 *
 * Requires:  
 * - Mbo.h
 * - MboSynch.h / MboSynch.cpp
 */
/* ------------------------------------------------------------------------ */

#ifndef _MBOLOCKEDVAR_H_
#define _MBOLOCKEDVAR_H_

#include "Mbo.h"
#include "MboSynch.h"

namespace mbo {

template <class _Ty, class _THREAD_MODEL = ThreadModel>
class LockedVar
{
private:

    typedef typename _THREAD_MODEL::CriticalSection CriticalSection;

    mutable CriticalSection  m_mx; /* lock to use */

protected:

    _Ty  m_val; 
public:

    inline LockedVar()
        : m_val()
    {
    }

    inline LockedVar(_IN const _Ty& tIn)
        : m_val(tIn)
    {
    }

    inline operator _Ty ()
    {
        Lock lock(&m_mx);
        return m_val;
    }

    inline operator const _Ty () const
    {
        Lock lock(&m_mx);
        return m_val;
    }

    inline _Ty& operator*()
    {
        Lock lock(&m_mx);
        return m_val;
    }

    inline const _Ty& operator*() const
    {
        Lock lock(&m_mx);
        return m_val;
    }

    inline const _Ty& operator= (_IN const _Ty& tIn)
    {
        Lock lock(&m_mx);
        m_val = tIn;
        return tIn; /* tIn not t */
    }

    inline _Ty __exchange(_IN const _Ty& tIn)
    {
        Lock lock(&m_mx);
        T tOld(m_val);
        m_val = tIn;
        return tOld; /* the old value */
    }

    inline mbo::CLock __getLock() const
    {
        return mbo::CLockSingle(&m_mx);
    }
};

template <>
class LockedVar<bool>
{
private:

    typedef ThreadModel::CriticalSection  CriticalSection;
    
    mutable CriticalSection  m_mx; /* lock to use */

protected:

    typedef bool _Ty;

    bool m_val; 
public:

    inline LockedVar()
        : m_val(false)
    {
    }

    inline explicit LockedVar(_IN const _Ty tIn)
        : m_val(tIn)
    {
    }

    inline operator _Ty ()
    {
        return m_val;
    }

    inline operator const _Ty () const
    {
        return m_val;
    }

    inline _Ty& operator*()
    {
        return m_val;
    }

    inline const _Ty& operator*() const
    {
        return m_val;
    }

    inline const _Ty& operator= (_IN const _Ty& tIn)
    {
        m_val = tIn;
        return tIn; /* tIn not t */
    }

    inline _Ty __exchange(_IN const _Ty tIn)
    {
        _Ty tOld(m_val);
        m_val = tIn;
        return tOld; /* the old value */
    }

    inline mbo::CLock __getLock() const
    {
        return mbo::CLockSingle(&m_mx);
    }
};

}; // namespace mbo

#endif // _MBOLOCKEDVAR_H_

---