#ifndef BOOST_LOCKFREE_SPSC_QUEUE_UNIQUE_PTR_HPP_INCLUDED
#define BOOST_LOCKFREE_SPSC_QUEUE_UNIQUE_PTR_HPP_INCLUDED

#include <boost/config.hpp>
#include <boost/lockfree/spsc_queue.hpp>

#ifndef BOOST_NO_CXX11_SMART_PTR

#include <cassert>
#include <memory>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_convertible.hpp>

namespace boost {
namespace lockfree {

template <typename T>
class spsc_queue<std::unique_ptr<T>>
{
    typedef typename std::unique_ptr<T>::pointer pointer_type;
    typedef spsc_queue<pointer_type> queue_type;

public:
    typedef T value_type;
    typedef typename queue_type::size_type size_type;

    spsc_queue(size_type size)
        : container(size)
    {
    }

    ~spsc_queue()
    {
        while (!container.empty())
        {
            std::unique_ptr<value_type> value;
            pop(value);
        }
    }

    bool empty()
    {
        return container.empty();
    }

    bool push(std::unique_ptr<value_type>& item)
    {
        auto status = container.push(item.get());
        if (status)
        {
            item.release();
        }
        return status;
    }

    template <typename U>
    typename boost::enable_if_c< boost::is_convertible<value_type, U>::value, bool>::type
    pop(std::unique_ptr<U>& item)
    {
        assert(!container.empty());

        value_type *value = nullptr;
        auto status = container.pop(value);
        if (status)
        {
            item.reset(value);
        }
        return status;
    }

private:
    queue_type container;
};

} // namespace lockfree
} // namespace boost

#endif

#endif // BOOST_LOCKFREE_SPSC_QUEUE_UNIQUE_PTR_HPP_INCLUDED