monitor.h

/* Copyright (c) 2006-2017, Stefan Eilemann <eile@equalizergraphics.com>
 *                          Cedric Stalder <cedric.stalder@gmail.com>
 *                          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/scopedMutex.h> // used inline
#include <lunchbox/types.h>

#include <boost/bind.hpp>
#include <condition_variable>
#include <errno.h>
#include <functional>
#include <iostream>
#include <mutex>
#include <string.h>
#include <typeinfo>

namespace lunchbox
{
template <class T>
class Monitor
{
    typedef void (Monitor<T>::*bool_t)() const;
    void bool_true() const {}
public:
    Monitor()
        : _value(T(0))
    {
    }

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

    Monitor(const Monitor<T>& from)
        : _value(from._value)
    {
    }

    ~Monitor() {}
    Monitor& operator++()
    {
        std::unique_lock<std::mutex> lock(_mutex);
        ++_value;
        _condition.notify_all();
        return *this;
    }

    Monitor& operator--()
    {
        std::unique_lock<std::mutex> lock(_mutex);
        --_value;
        _condition.notify_all();
        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)
    {
        std::unique_lock<std::mutex> lock(_mutex);
        _value |= value;
        _condition.notify_all();
        return *this;
    }

    Monitor& operator&=(const T& value)
    {
        std::unique_lock<std::mutex> lock(_mutex);
        _value &= value;
        _condition.notify_all();
        return *this;
    }

    T set(const T& value)
    {
        std::unique_lock<std::mutex> lock(_mutex);
        const T old = _value;
        _value = value;
        _condition.notify_all();
        return old;
    }

    const T waitEQ(const T& value) const
    {
        return _wait([&] { return _value == value; });
    }

    const T waitNE(const T& value) const
    {
        return _wait([&] { return _value != value; });
    }

    const T waitNE(const T& v1, const T& v2) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        _condition.wait(lock, [&] { return _value != v1 && _value != v2; });
        return _value;
    }

    const T waitGE(const T& value) const
    {
        return _wait([&] { return _value >= value; });
    }

    const T waitLE(const T& value) const
    {
        return _wait([&] { return _value <= value; });
    }

    const T waitGT(const T& value) const
    {
        return _wait([&] { return _value > value; });
    }

    const T waitLT(const T& value) const
    {
        return _wait([&] { return _value < value; });
    }

    bool timedWaitEQ(const T& value, const uint32_t timeout) const
    {
        return _timedWait([&] { return _value == value; }, timeout);
    }

    bool timedWaitNE(const T& value, const uint32_t timeout) const
    {
        return _timedWait([&] { return _value != value; }, timeout);
    }

    bool timedWaitGE(const T& value, const uint32_t timeout) const
    {
        return _timedWait([&] { return _value >= value; }, timeout);
    }

    bool timedWaitLE(const T& value, const uint32_t timeout) const
    {
        return _timedWait([&] { return _value <= value; }, timeout);
    }

    bool timedWaitGT(const T& value, const uint32_t timeout) const
    {
        return _timedWait([&] { return _value > value; }, timeout);
    }

    bool timedWaitLT(const T& value, const uint32_t timeout) const
    {
        return _timedWait([&] { return _value < value; }, timeout);
    }


    bool operator==(const T& value) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return _value == value;
    }
    bool operator!=(const T& value) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return _value != value;
    }
    bool operator<(const T& value) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return _value < value;
    }
    bool operator>(const T& value) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return _value > value;
    }
    bool operator<=(const T& value) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return _value <= value;
    }
    bool operator>=(const T& value) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return _value >= value;
    }

    bool operator==(const Monitor<T>& rhs) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return _value == rhs._value;
    }
    bool operator!=(const Monitor<T>& rhs) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return _value != rhs._value;
    }
    bool operator<(const Monitor<T>& rhs) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return _value < rhs._value;
    }
    bool operator>(const Monitor<T>& rhs) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return _value > rhs._value;
    }
    bool operator<=(const Monitor<T>& rhs) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return _value <= rhs._value;
    }
    bool operator>=(const Monitor<T>& rhs) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return _value >= rhs._value;
    }
    operator bool_t()
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return _value ? &Monitor<T>::bool_true : 0;
    }

    const T& operator->() const { return _value; }
    const T& get() const { return _value; }
    T operator+(const T& value) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return _value + value;
    }

    T operator|(const T& value) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return static_cast<T>(_value | value);
    }

    T operator&(const T& value) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return static_cast<T>(_value & value);
    }

private:
    T _value;
    mutable std::mutex _mutex;
    mutable std::condition_variable _condition;

    template <typename F>
    const T _wait(const F& predicate) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        _condition.wait(lock, predicate);
        return _value;
    }

    template <typename F>
    bool _timedWait(const F& predicate, const uint32_t timeout) const
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return _condition.wait_for(lock, std::chrono::milliseconds(timeout),
                                   predicate);
    }
};

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++()
{
    std::unique_lock<std::mutex> lock(_mutex);
    assert(!_value);
    _value = !_value;
    _condition.notify_all();
    return *this;
}

template <>
inline Monitor<bool>& Monitor<bool>::operator--()
{
    std::unique_lock<std::mutex> lock(_mutex);
    assert(!_value);
    _value = !_value;
    _condition.notify_all();
    return *this;
}

template <>
inline Monitor<bool>& Monitor<bool>::operator|=(const bool& value)
{
    if (value)
    {
        std::unique_lock<std::mutex> lock(_mutex);
        _value = value;
        _condition.notify_all();
    }
    return *this;
}
}

#include <servus/uint128_t.h>
namespace lunchbox
{
template <>
inline Monitor<servus::uint128_t>::Monitor()
{
}
}

#endif // LUNCHBOX_MONITOR_H