monitor.h

/* Copyright (c) 2006-2012, Stefan Eilemann <eile@equalizergraphics.com>
 *                    2011, Cedric Stalder <cedric.stalder@gmail.com>
 *               2011-2012, Daniel Nachbaur <danielnachbaur@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 LUNCHBOX_MONITOR_H
#define LUNCHBOX_MONITOR_H

#include <lunchbox/nonCopyable.h> // base class
#include <lunchbox/condition.h>   // member
#include <lunchbox/scopedMutex.h> // used inline
#include <lunchbox/types.h>

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

namespace lunchbox
{
    template< class 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++ ()
            {
                ScopedCondition mutex( _cond );
                ++_value;
                _cond.broadcast();
                return *this;
            }

        Monitor& operator-- ()
            {
                ScopedCondition mutex( _cond );
                --_value;
                _cond.broadcast();
                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 )
            {
                ScopedCondition mutex( _cond );
                _value |= value;
                _cond.broadcast();
                return *this;
            }

        Monitor& operator &= ( const T& value )
            {
                ScopedCondition mutex( _cond );
                _value &= value;
                _cond.broadcast();
                return *this;
            }

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

        const T& waitEQ( const T& value ) const
            {
                if( sizeof( T ) <= 8 && _value == value )
                    return value;
                ScopedCondition mutex( _cond );
                while( _value != value )
                    _cond.wait();
                return value;
            }

        const T waitNE( const T& value ) const
            {
                if( sizeof( T ) <= 8 ) // issue #1
                {
                    const T current = _value;
                    if( current != value )
                        return current;
                }
                ScopedCondition mutex( _cond );
                while( _value == value )
                    _cond.wait();
                return _value;
            }

        const T waitNE( const T& v1, const T& v2 ) const
            {
                if( sizeof( T ) <= 8 ) // issue #1
                {
                    const T current = _value;
                    if( current != v1 && current != v2 )
                        return current;
                }
                ScopedCondition mutex( _cond );
                while( _value == v1 || _value == v2 )
                    _cond.wait();
                return _value;
            }

        const T waitGE( const T& value ) const
            {
                if( sizeof( T ) <= 8 ) // issue #1
                {
                    const T current = _value;
                    if( current >= value )
                        return current;
                }
                ScopedCondition mutex( _cond );
                while( _value < value )
                    _cond.wait();
                return _value;
            }
        const T waitLE( const T& value ) const
            {
                if( sizeof( T ) <= 8 ) // issue #1
                {
                    const T current = _value;
                    if( current <= value )
                        return current;
                }
                ScopedCondition mutex( _cond );
                while( _value > value )
                    _cond.wait();
                return _value;
            }

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

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

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

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

        bool timedWaitNE( const T& value, const uint32_t timeout ) const
            {
                if( sizeof( T ) <= 8 && _value != value )
                    return true;

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

        bool operator == ( const T& value ) const
            {
                ScopedCondition mutex( sizeof(T)>8 ? &_cond : 0 ); // issue #1
                return _value == value;
            }
        bool operator != ( const T& value ) const
            {
                ScopedCondition mutex( sizeof(T)>8 ? &_cond : 0 ); // issue #1
                return _value != value;
            }
        bool operator < ( const T& value ) const
            {
                ScopedCondition mutex( sizeof(T)>8 ? &_cond : 0 ); // issue #1
                return _value < value;
            }
        bool operator > ( const T& value ) const
            {
                ScopedCondition mutex( sizeof(T)>8 ? &_cond : 0 ); // issue #1
                return _value > value;
            }
        bool operator <= ( const T& value ) const
            {
                ScopedCondition mutex( sizeof(T)>8 ? &_cond : 0 ); // issue #1
                return _value <= value;
            }
        bool operator >= ( const T& value ) const
            {
                ScopedCondition mutex( sizeof(T)>8 ? &_cond : 0 ); // issue #1
                return _value >= value;
            }

        bool operator == ( const Monitor<T>& rhs ) const
            {
                ScopedCondition mutex( sizeof(T)>8 ? &_cond : 0 ); // issue #1
                return _value == rhs._value;
            }
        bool operator != ( const Monitor<T>& rhs ) const
            {
                ScopedCondition mutex( sizeof(T)>8 ? &_cond : 0 ); // issue #1
                return _value != rhs._value;
            }
        bool operator < ( const Monitor<T>& rhs ) const
            {
                ScopedCondition mutex( sizeof(T)>8 ? &_cond : 0 ); // issue #1
                return _value < rhs._value;
            }
        bool operator > ( const Monitor<T>& rhs ) const
            {
                ScopedCondition mutex( sizeof(T)>8 ? &_cond : 0 ); // issue #1
                return _value > rhs._value;
            }
        bool operator <= ( const Monitor<T>& rhs ) const
            {
                ScopedCondition mutex( sizeof(T)>8 ? &_cond : 0 ); // issue #1
                return _value <= rhs._value;
            }
        bool operator >= ( const Monitor<T>& rhs ) const
            {
                ScopedCondition mutex( sizeof(T)>8 ? &_cond : 0 ); // issue #1
                return _value >= rhs._value;
            }

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

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

        T operator + ( const T& value ) const
            {
                ScopedCondition mutex( sizeof(T)>8 ? &_cond : 0 ); // issue #1
                return _value + value;
            }

        T operator | ( const T& value ) const
            {
                ScopedCondition mutex( sizeof(T)>8 ? &_cond : 0 ); // issue #1
                return static_cast< T >( _value | value );
            }

        T operator & ( const T& value ) const
            {
                ScopedCondition mutex( sizeof(T)>8 ? &_cond : 0 ); // issue #1
                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++ ()
    {
        ScopedCondition mutex( _cond );
        assert( !_value );
        _value = !_value;
        _cond.broadcast();
        return *this;
    }

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

    template<>
    inline Monitor< bool >& Monitor< bool >::operator |= ( const bool& value )
    {
        if( value )
        {
            ScopedCondition mutex( _cond );
            _value = value;
            _cond.broadcast();
        }
        return *this;
    }
}
#endif //LUNCHBOX_MONITOR_H