mtQueue.h

/* Copyright (c) 2005-2017, Stefan Eilemann <eile@equalizergraphics.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_MTQUEUE_H
#define LUNCHBOX_MTQUEUE_H

#include <lunchbox/debug.h>

#include <algorithm>
#include <condition_variable>
#include <limits.h>
#include <mutex>
#include <queue>
#include <string.h>

namespace lunchbox
{
template <typename T, size_t S = ULONG_MAX>
class MTQueue
// S = std::numeric_limits< size_t >::max() does not work:
//   http://gcc.gnu.org/bugzilla/show_bug.cgi?id=6424
{
public:
    class Group;
    typedef T value_type;

    explicit MTQueue(const size_t maxSize = S)
        : _maxSize(maxSize)
    {
    }

    MTQueue(const MTQueue<T, S>& from) { *this = from; }
    ~MTQueue() {}
    MTQueue<T, S>& operator=(const MTQueue<T, S>& from);

    const T& operator[](const size_t index) const;

    bool isEmpty() const { return _queue.empty(); }
    size_t getSize() const { return _queue.size(); }
    void setMaxSize(const size_t maxSize);

    size_t getMaxSize() const { return _maxSize; }
    size_t waitSize(const size_t minSize) const;

    void clear();

    T pop();

    bool timedPop(const unsigned timeout, T& element);

    std::vector<T> timedPopRange(const unsigned timeout,
                                 const size_t minimum = 1,
                                 const size_t maximum = S);

    bool tryPop(T& result);

    void tryPop(const size_t num, std::vector<T>& result);

    bool popBarrier(T& result, Group& barrier);

    bool getFront(T& result) const;

    bool getBack(T& result) const;

    void push(const T& element);

    void push(const std::vector<T>& elements);

    void pushFront(const T& element);

    void pushFront(const std::vector<T>& elements);

    void push_back(const T& element) { push(element); }
    bool empty() const { return isEmpty(); }

private:
    MTQueue(MTQueue<T, S>&&) = delete;
    MTQueue<T, S>& operator=(MTQueue<T, S>&&) = delete;

    std::deque<T> _queue;
    mutable std::mutex _mutex;
    mutable std::condition_variable _condition;
    size_t _maxSize;
};
}

#include "mtQueue.ipp" // template implementation

#endif // LUNCHBOX_MTQUEUE_H