BoundedBuffer.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 BOUNDEDBUFFER
#define BOUNDEDBUFFER

#include <mutex>
#include <condition_variable>
#include <functional>
#include <boost/circular_buffer.hpp>
#include <boost/call_traits.hpp>

namespace core_lib
{
namespace threads
{

template <typename T> class BoundedBuffer final
{
public:
    using container_type = boost::circular_buffer<T>;
    using size_type = typename container_type::size_type;
    using value_type = typename container_type::value_type;
    using param_type = typename boost::call_traits<value_type>::param_type;
    explicit BoundedBuffer(size_type capacity)
        : m_container{capacity}
    {
    }
    ~BoundedBuffer() = default;
    BoundedBuffer(const BoundedBuffer&) = delete;
    BoundedBuffer& operator=(const BoundedBuffer&) = delete;
    BoundedBuffer(BoundedBuffer&&) = delete;
    BoundedBuffer& operator=(BoundedBuffer&&) = delete;
    void PushFront(param_type item)
    {
        {
            std::unique_lock<std::mutex> lock{m_mutex};
            m_notFullEvent.wait(lock, std::bind(&BoundedBuffer<value_type>::IsNotFull, this));
            m_container.push_front(item);
            ++m_unreadCount;
        }

        m_notEmptyEvent.notify_one();
    }
    void PopBack(value_type& item)
    {
        {
            std::unique_lock<std::mutex> lock{m_mutex};
            m_notEmptyEvent.wait(lock, std::bind(&BoundedBuffer<value_type>::IsNotEmpty, this));
            item = m_container[--m_unreadCount];
        }

        m_notFullEvent.notify_one();
    }

private:
    std::mutex m_mutex;
    std::condition_variable m_notEmptyEvent;
    std::condition_variable m_notFullEvent;
    size_type m_unreadCount{0};
    container_type m_container{};
    bool IsNotEmpty() const
    {
        return m_unreadCount > 0;
    }
    bool IsNotFull() const
    {
        return m_unreadCount < m_container.capacity();
    }
};

} // namespace threads
} // namespace core_lib
#endif // BOUNDEDBUFFER