monitor.h

/* Copyright (c) 2006-2011, Stefan Eilemann <eile@equalizergraphics.com> 
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *  
 * 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.
 */

#ifndef COBASE_MONITOR_H
#define COBASE_MONITOR_H

#include <co/base/nonCopyable.h> // base class
#include <co/base/condition.h>   // member
#include <co/base/types.h>

#include <errno.h>
#include <string.h>
#include <iostream>
#include <typeinfo>

namespace co
{
namespace base
{
    template< typename T > class Monitor : public NonCopyable
    {
    public:
        Monitor() : _value( T( 0 )) {}

        Monitor( const T& value ) : _value( value ) {}
        
        ~Monitor() {}

        Monitor& operator++ ()
            {
                _cond.lock();
                ++_value;
                _cond.broadcast();
                _cond.unlock();
                return *this;
            }

        Monitor& operator-- ()
            {
                _cond.lock();
                --_value;
                _cond.broadcast();
                _cond.unlock();
                return *this;
            }

        Monitor& operator = ( const T& value )
            {
                set( value );
                return *this;
            }

        Monitor& operator |= ( const T& value )
            {
                _cond.lock();
                _value |= value;
                _cond.broadcast();
                _cond.unlock();
                return *this;
            }

        void set( const T& value )
            {
                _cond.lock();
                _value = value;
                _cond.broadcast();
                _cond.unlock();
            }

        const T& waitEQ( const T& value ) const
            {
                _cond.lock();
                while( _value != value )
                    _cond.wait();
                _cond.unlock();
                return value;
            }

        const T& waitNE( const T& value ) const
            {
                _cond.lock();
                while( _value == value )
                    _cond.wait();
                const T& newValue = _value;
                _cond.unlock();
                return newValue;
            }

        const T& waitNE( const T& v1, const T& v2 ) const
            {
                _cond.lock();
                while( _value == v1 || _value == v2 )
                    _cond.wait();
                const T& newValue = _value;
                _cond.unlock();
                return newValue;
            }

        const T& waitGE( const T& value ) const
            {
                _cond.lock();
                while( _value < value )
                    _cond.wait();
                const T& newValue = _value;
                _cond.unlock();
                return newValue;
            }

        const T& waitLE( const T& value ) const
            {
                _cond.lock();
                while( _value > value )
                    _cond.wait();
                const T& newValue = _value;
                _cond.unlock();
                return newValue;
            }


        bool operator == ( const T& value ) const { return _value == value; }
        bool operator != ( const T& value ) const { return _value != value; }
        bool operator < ( const T& value ) const { return _value < value; }
        bool operator > ( const T& value ) const { return _value > value; }
        bool operator <= ( const T& value ) const { return _value <= value; }
        bool operator >= ( const T& value ) const { return _value >= value; }

        bool operator == ( const Monitor<T>& rhs ) const
            { return _value == rhs._value; }
        bool operator != ( const Monitor<T>& rhs ) const
            { return _value != rhs._value; }
        bool operator < ( const Monitor<T>& rhs ) const
            { return _value < rhs._value; }
        bool operator > ( const Monitor<T>& rhs ) const
            { return _value > rhs._value; }
        bool operator <= ( const Monitor<T>& rhs ) const
            { return _value <= rhs._value; }
        bool operator >= ( const Monitor<T>& rhs ) const
            { return _value >= rhs._value; }

        const T& operator->() const { return _value; }

        const T& get() const { return _value; }

        T operator + ( const T& value ) const { return _value + value; }

        T operator | ( const T& value ) const
            { return static_cast< T >( _value | value ); }

        T operator & ( const T& value ) const
            { return static_cast< T >( _value & value ); }

    private:
        T _value;
        mutable Condition _cond;
    };

    typedef Monitor< bool >     Monitorb; 
    typedef Monitor< uint32_t > Monitoru; 

    template< typename T >
    inline std::ostream& operator << ( std::ostream& os,
                                       const Monitor<T>& monitor )
    {
        os << "Monitor< " << monitor.get() << " >";
        return os;
    }

    template<> inline Monitor< bool >& Monitor< bool >::operator++ ()
    {
        _cond.lock();
        assert( !_value );
        _value = !_value;
        _cond.broadcast();
        _cond.unlock();
        return *this;
    }

    template<> inline Monitor< bool >& Monitor< bool >::operator-- ()
    {
        _cond.lock();
        assert( !_value );
        _value = !_value;
        _cond.broadcast();
        _cond.unlock();
        return *this;
    }

    template<> 
    inline Monitor< bool >& Monitor< bool >::operator |= ( const bool& value )
    {
        if( value )
            _value = value;
        return *this;
    }
}
}
#endif //COBASE_MONITOR_H