ConcurrentQueue.h

Go to the documentation of this file.

// This file is part of CoreLibrary containing useful reusable utility
// classes.
//
// Copyright (C) 2014 to present, Duncan Crutchley
// Contact <dac1976github@outlook.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License and GNU Lesser General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License
// and GNU Lesser General Public License along with this program. If
// not, see <http://www.gnu.org/licenses/>.

#ifndef CONCURRENTQUEUE
#define CONCURRENTQUEUE

#include <deque>
#include <algorithm>
#include <utility>
#include <stdexcept>
#include <boost/throw_exception.hpp>
#include "SyncEvent.h"

namespace core_lib
{
namespace threads
{

template <typename P> struct SingleItemDeleter
{
    void operator()(P* p) const
    {
        delete p;
    }
};

template <typename P> struct ArrayDeleter
{
    void operator()(P* p) const
    {
        delete[] p;
    }
};

template <typename T> class ConcurrentQueue final
{
public:
    ConcurrentQueue() = default;
    ConcurrentQueue(const ConcurrentQueue&) = delete;
    ConcurrentQueue& operator=(const ConcurrentQueue&) = delete;
    ConcurrentQueue(ConcurrentQueue&&) = delete;
    ConcurrentQueue& operator=(ConcurrentQueue&&) = delete;
    ~ConcurrentQueue() = default;
    size_t Size() const
    {
        std::lock_guard<std::mutex> lock{m_mutex};
        return m_queue.size();
    }
    bool Empty() const
    {
        std::lock_guard<std::mutex> lock{m_mutex};
        return m_queue.empty();
    }
    void Push(T&& item)
    {
        {
            std::lock_guard<std::mutex> lock{m_mutex};
            m_queue.emplace_back(std::move(item));
        }

        m_itemEvent.Signal();
    }
    void Push(const T& item)
    {
        {
            std::lock_guard<std::mutex> lock{m_mutex};
            m_queue.emplace_back(item);
        }

        m_itemEvent.Signal();
    }
    void BreakPopWait()
    {
        m_itemEvent.Signal();
    }
    bool Pop(T& item)
    {
        m_itemEvent.Wait();
        return PopNow(item);
    }
    void PopThrow(T& item)
    {
        m_itemEvent.Wait();

        if (!PopNow(item))
        {
            BOOST_THROW_EXCEPTION(std::runtime_error("no item to pop"));
        }
    }
    bool TryPop(T& item)
    {
        return PopNow(item);
    }
    void TryPopThrow(T& item)
    {
        if (!PopNow(item))
        {
            BOOST_THROW_EXCEPTION(std::runtime_error("no item to pop"));
        }
    }
    bool TimedPop(unsigned int timeoutMilliseconds, T& item)
    {
        bool popSuccess{false};

        if (m_itemEvent.WaitForTime(timeoutMilliseconds))
        {
            popSuccess = PopNow(item);
        }

        return popSuccess;
    }
    void TimedPopThrow(unsigned int timeoutMilliseconds, T& item)
    {
        if (!m_itemEvent.WaitForTime(timeoutMilliseconds))
        {
            BOOST_THROW_EXCEPTION(std::runtime_error("item event timed out"));
        }

        if (!PopNow(item))
        {
            BOOST_THROW_EXCEPTION(std::runtime_error("no item to pop"));
        }
    }
    bool TrySteal(T& item)
    {
        return PopNow(item, eQueueEnd::back);
    }
    void TryStealThrow(T& item)
    {
        if (!PopNow(item, eQueueEnd::back))
        {
            BOOST_THROW_EXCEPTION(std::runtime_error("no item to pop"));
        }
    }
    const T* Peek(size_t index) const
    {
        const T*                    pItem{};
        std::lock_guard<std::mutex> lock{m_mutex};

        if (!m_queue.empty() && (index < m_queue.size()))
        {
            pItem = &m_queue[index];
        }

        return pItem;
    }
    void Clear()
    {
        std::lock_guard<std::mutex> lock{m_mutex};
        m_queue.clear();
    }
    template <typename F> void Clear(F deleter)
    {
        std::lock_guard<std::mutex> lock{m_mutex};

        for (auto& qi : m_queue)
        {
            deleter(qi);
        }

        m_queue.clear();
    }
    using container_type = std::deque<T>;
    container_type TakeAll()
    {
        container_type q{};

        {
            std::lock_guard<std::mutex> lock{m_mutex};
            q.swap(m_queue);
        }

        return q;
    }

private:
    enum class eQueueEnd
    {
        front,
        back
    };
    bool PopNow(T& item, eQueueEnd whichEnd = eQueueEnd::front)
    {
        std::lock_guard<std::mutex> lock{m_mutex};
        auto                        isEmpty = m_queue.empty();

        if (!isEmpty)
        {
            if (whichEnd == eQueueEnd::front)
            {
                PopFront(item);
            }
            else
            {
                PopBack(item);
            }
        }

        if (m_queue.empty())
        {
            m_itemEvent.Reset();
        }

        return !isEmpty;
    }

    void PopFront(T& item)
    {
        item = std::move(m_queue.front());
        m_queue.pop_front();
    }

    void PopBack(T& item)
    {
        item = std::move(m_queue.back());
        m_queue.pop_back();
    }

private:
    mutable std::mutex m_mutex;
    SyncEvent m_itemEvent{
        eNotifyType::signalOneThread, eResetCondition::manualReset, eIntialCondition::notSignalled};
    container_type m_queue{};
};

} // namespace threads
} // namespace core_lib

#endif // CONCURRENTQUEUE