monitor.h

/* Copyright (c) 2006-2011, Stefan Eilemann <eile@equalizergraphics.com> 
 *                    2011, Cedric Stalder <cedric.stalder@gmail.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:
        Monitor() : _value( T( 0 )) {}

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

        Monitor( const Monitor< T >& from ) : _value( from._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;
            }

        const Monitor& operator = ( const Monitor< T >& from )
            {
                set( from._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
            {
                if( _value == value )
                    return value;
                _cond.lock();
                while( _value != value )
                    _cond.wait();
                _cond.unlock();
                return value;
            }

        const T waitNE( const T& value ) const
            {
                const T current = _value;
                if( current != value )
                    return current;

                _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
            {
                const T current = _value;
                if( current != v1 && current != v2 )
                    return current;

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

         const T waitGE( const T& value ) const
            {
                const T current = _value;
                if( current >= value )
                    return current;

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

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

        bool timedWaitEQ( const T& value, const uint32_t timeout ) const
            {
                if( _value == value )
                    return true;

                _cond.lock();
                while( _value != value )
                {
                    if( !_cond.timedWait( timeout ) )
                    {
                        _cond.unlock();
                        return false;
                    }
                }
                _cond.unlock();
                return true;
            }

       bool timedWaitGE( const T& value, const uint32_t timeout ) const
            {
                if( _value >= value )
                    return true;

                _cond.lock();
                while( _value < value )
                {
                    if ( !_cond.timedWait( timeout ) )
                    {
                        _cond.unlock();
                        return false;
                    }
                }
                _cond.unlock();
                return true;
            }

        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