MNProtectedVar.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef MNPROTECTEDVAR_TYPE_H
#define MNPROTECTEDVAR_TYPE_H

#include <config.h>

#include "mnstream.h"
#include "MNMutex.h"

/***********************************************************************
 * ProtectedVar<T>
 * - protects integer-like variables with a mutex
 ***********************************************************************/

/* Template Protected Var - use it for creating mutexed protected numeric variables*/
template<class T> class ProtectedVar
{
  T       _x;
  MNMutex _m;
public:
    ProtectedVar ( T i )
        :_x(i)
    {
    }
    
    ProtectedVar ()
    {
        _x=(T) 0;
    }

    inline ProtectedVar<T>& operator= ( T i );
    inline ProtectedVar<T>& operator+=( T i );
    inline ProtectedVar<T>& operator-=( T i );

    inline bool operator==( T i );
    inline bool operator!=( T i );

    inline T operator++();
    inline T operator++(int);
    inline T operator--();
    inline T operator--(int);

    inline T replace( T nval );

    inline operator T();    // implicit typecast operator

    //friend ostream& operator<< ( ostream&, ProtectedVar<T>& );

    inline void print_T( ostream& ostr );
   
};

template<class T>
inline ProtectedVar<T>& ProtectedVar<T>::operator=( T i )
{
    _m.lock();
    _x = i;
    _m.unlock();
    return *this;
}

template<class T>
inline ProtectedVar<T>& ProtectedVar<T>::operator+=(T i)
{
    _m.lock();
    _x+=i;
    _m.unlock();
    return *this;
}

template<class T>
inline ProtectedVar<T>& ProtectedVar<T>::operator-=(T i)
{
    _m.lock();
    _x-=i;
    _m.unlock();
    return *this;
}

template<class T>
inline bool ProtectedVar<T>::operator==( T i )
{
    _m.lock();
    bool ret = ( _x == i );
    _m.unlock();
    return ret;
}

template<class T>
inline bool ProtectedVar<T>::operator!=( T i )
{
    _m.lock();
    bool ret = ( _x != i );
    _m.unlock();
    return ret;
}

template<class T>
inline T ProtectedVar<T>::operator++()
{
    _m.lock();
    T ret = ++_x;
    _m.unlock();
    return ret;
}

template<class T>
inline T ProtectedVar<T>::operator++(int)
{
    _m.lock();
    T ret = _x++;
    _m.unlock();
    return ret;
}

template<class T>
inline T ProtectedVar<T>::operator--()
{
    _m.lock();
    T ret = --_x;
    _m.unlock();
    return ret;  
}

template<class T>
inline T ProtectedVar<T>::operator--(int)
{
    _m.lock();
    T ret = _x--;
    _m.unlock();
    return ret;
}

template<class T>
inline T ProtectedVar<T>::replace( T nval )
{
    _m.lock();
    T ret = _x;
    _x    = nval;
    _m.unlock();
    return ret;
}

template<class T>
inline ProtectedVar<T>::operator T()    // implicit typecast operator
{
    _m.lock();
    T ret = _x;
    _m.unlock();
    return ret;
}

template<class T>
inline void ProtectedVar<T>::print_T( ostream& ostr )
{
    _m.lock();
    ostr << _x;
    _m.unlock();
}
   
extern ostream& operator<< ( ostream& ostr, ProtectedVar<int>& pi );

/***********************************************************************
 * ProtectedPtr<T>
 * - protects known pointer variables with a mutex
 ***********************************************************************/

/* Template Protected Var - use it for creating mutexed protected numeric variables*/
template<class T> class ProtectedPtr
{
  T       _x;
  MNMutex _m;
public:
    ProtectedPtr ( T i )
        :_x(i)
    {
    }
    
    ProtectedPtr ()
    {
        _x=(T) 0;
    }

    inline ProtectedPtr<T>& operator= ( T i );
    inline ProtectedPtr<T>& operator+=( int i );
    inline ProtectedPtr<T>& operator-=( int i );

    inline bool operator==( T i );
    inline bool operator!=( T i );

    inline T operator++();
    inline T operator++(int);
    inline T operator--();
    inline T operator--(int);

    inline T replace( T nval );

    inline operator T();    // implicit typecast operator

    //friend ostream& operator<< ( ostream&, ProtectedPtr<T>& );

    inline void print_T( ostream& ostr );
   
};

template<class T>
inline ProtectedPtr<T>& ProtectedPtr<T>::operator=( T i )
{
    _m.lock();
    _x = i;
    _m.unlock();
    return *this;
}

template<class T>
inline ProtectedPtr<T>& ProtectedPtr<T>::operator+=(int i)
{
    _m.lock();
    _x+=i;
    _m.unlock();
    return *this;
}

template<class T>
inline ProtectedPtr<T>& ProtectedPtr<T>::operator-=(int i)
{
    _m.lock();
    _x-=i;
    _m.unlock();
    return *this;
}

template<class T>
inline bool ProtectedPtr<T>::operator==( T i )
{
    _m.lock();
    bool ret = ( _x == i );
    _m.unlock();
    return ret;
}

template<class T>
inline bool ProtectedPtr<T>::operator!=( T i )
{
    _m.lock();
    bool ret = ( _x != i );
    _m.unlock();
    return ret;
}

template<class T>
inline T ProtectedPtr<T>::operator++()
{
    _m.lock();
    T ret = ++_x;
    _m.unlock();
    return ret;
}

template<class T>
inline T ProtectedPtr<T>::operator++(int)
{
    _m.lock();
    T ret = _x++;
    _m.unlock();
    return ret;
}

template<class T>
inline T ProtectedPtr<T>::operator--()
{
    _m.lock();
    T ret = --_x;
    _m.unlock();
    return ret;  
}

template<class T>
inline T ProtectedPtr<T>::operator--(int)
{
    _m.lock();
    T ret = _x--;
    _m.unlock();
    return ret;
}

template<class T>
inline T ProtectedPtr<T>::replace( T nval )
{
    _m.lock();
    T ret = _x;
    _x    = nval;
    _m.unlock();
    return ret;
}

template<class T>
inline ProtectedPtr<T>::operator T()    // implicit typecast operator
{
    _m.lock();
    T ret = _x;
    _m.unlock();
    return ret;
}

template<class T>
inline void ProtectedPtr<T>::print_T( ostream& ostr )
{
    _m.lock();
    ostr << _x;
    _m.unlock();
}
   
extern ostream& operator<< ( ostream& ostr, ProtectedPtr<int>& pi );

/***********************************************************************
 * ProtectedVarEnum<T>
 * - protects enum variable with a mutex
 ***********************************************************************/

template<class T> class ProtectedVarEnum
{
    T       _x;
    mutable MNMutex _m;
public:
    ProtectedVarEnum( T i )
        :_x(i)
    {
    }
    
    ProtectedVarEnum()
    {
        _x=(T) 0;
    }

    ProtectedVarEnum<T>& operator=( T i )
    {
        _m.lock();
        _x = i;
        _m.unlock();
        return *this;
    }

    bool operator==( T i ) const
    {
        _m.lock();
        bool ret = ( _x == i );
        _m.unlock();
        return ret;
    }

    operator T() const    // implicit typecast operator
    {
        _m.lock();
        T ret = _x;
        _m.unlock();
        return ret;
    }
};


class ProtectedBool
{
  bool    _x;
  MNMutex _m;
public:
    ProtectedBool ( bool i )
        :_x(i)
    {
    }
    
    ProtectedBool ()
      {
        _x=false;
      }

    ProtectedBool& operator=( bool i )
    {
        _m.lock();
        _x = i;
        _m.unlock();
        return *this;
    }

    bool operator==( bool i )
    {
        _m.lock();
        bool ret = ( _x == i );
        _m.unlock();
        return ret;
    }

    operator bool()    // implicit typecast operator
    {
        _m.lock();
        bool ret = _x;
        _m.unlock();
        return ret;
    }

    void print_B( ostream& ostr )
    {
        _m.lock();
        if (_x)
          ostr << "true";
        else
          ostr << "false";
        _m.unlock();
    }

    friend ostream& operator << ( ostream&, ProtectedBool& );
};

#endif

---