FM / concurrent

/usr/include/boost/thread/concurrent_queues/

/usr/include/boost/thread/concurrent_queues

Name	Size	Mode	Actions
detail/	-	0755	rm
deque_adaptor.hpp	7793	0644	edit dl rm
deque_base.hpp	6478	0644	edit dl rm
deque_views.hpp	5947	0644	edit dl rm
queue_adaptor.hpp	7431	0644	edit dl rm
queue_base.hpp	6288	0644	edit dl rm
queue_op_status.hpp	1241	0644	edit dl rm
queue_views.hpp	4631	0644	edit dl rm
sync_bounded_queue.hpp	21454	0644	edit dl rm
sync_deque.hpp	10901	0644	edit dl rm
sync_priority_queue.hpp	11056	0644	edit dl rm
sync_queue.hpp	10554	0644	edit dl rm
sync_timed_queue.hpp	17019	0644	edit dl rm

Edit: /usr/include/boost/thread/concurrent_queues/queue_adaptor.hpp (7431B)

#ifndef BOOST_THREAD_QUEUE_ADAPTOR_HPP
#define BOOST_THREAD_QUEUE_ADAPTOR_HPP

//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Vicente J. Botet Escriba 2014. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/thread for documentation.
//
//////////////////////////////////////////////////////////////////////////////

#include <boost/thread/detail/config.hpp>
#include <boost/thread/detail/move.hpp>
#include <boost/thread/concurrent_queues/queue_op_status.hpp>
#include <boost/thread/concurrent_queues/queue_base.hpp>

#include <boost/config/abi_prefix.hpp>

namespace boost
{
namespace concurrent
{
namespace detail
{

template <typename Queue>
  class queue_adaptor_copyable_only :
    public boost::queue_base<typename Queue::value_type, typename Queue::size_type>
  {
      Queue queue;
  public:
    typedef typename Queue::value_type value_type;
    typedef typename Queue::size_type size_type;

// Constructors/Assignment/Destructors
    queue_adaptor_copyable_only()  {}

// Observers
    bool empty() const  { return queue.empty(); }
    bool full() const { return queue.full(); }
    size_type size() const { return queue.size(); }
    bool closed() const { return queue.closed(); }

// Modifiers
    void close() { queue.close(); }

void push(const value_type& x) { queue.push(x); }

void pull(value_type& x) { queue.pull(x); };
    value_type pull() { return queue.pull(); }

queue_op_status try_push(const value_type& x) { return queue.try_push(x); }
    queue_op_status try_pull(value_type& x)  { return queue.try_pull(x); }

queue_op_status nonblocking_push(const value_type& x) { return queue.nonblocking_push(x); }
    queue_op_status nonblocking_pull(value_type& x)  { return queue.nonblocking_pull(x); }

queue_op_status wait_push(const value_type& x) { return queue.wait_push(x); }
    queue_op_status wait_pull(value_type& x) { return queue.wait_pull(x); }

};
  template <typename Queue>
  class queue_adaptor_movable_only :
    public boost::queue_base<typename Queue::value_type, typename Queue::size_type>
  {
      Queue queue;
  public:
    typedef typename Queue::value_type value_type;
    typedef typename Queue::size_type size_type;

// Constructors/Assignment/Destructors

queue_adaptor_movable_only()  {}

// Modifiers
    void close() { queue.close(); }

void pull(value_type& x) { queue.pull(x); };
    // enable_if is_nothrow_copy_movable<value_type>
    value_type pull() { return queue.pull(); }

queue_op_status try_pull(value_type& x)  { return queue.try_pull(x); }

queue_op_status nonblocking_pull(value_type& x)  { return queue.nonblocking_pull(x); }

queue_op_status wait_pull(value_type& x) { return queue.wait_pull(x); }

void push(BOOST_THREAD_RV_REF(value_type) x) { queue.push(boost::move(x)); }
    queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) { return queue.try_push(boost::move(x)); }
    queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) { return queue.nonblocking_push(boost::move(x)); }
    queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x) { return queue.wait_push(boost::move(x)); }
  };

template <typename Queue>
  class queue_adaptor_copyable_and_movable :
    public boost::queue_base<typename Queue::value_type, typename Queue::size_type>
  {
      Queue queue;
  public:
    typedef typename Queue::value_type value_type;
    typedef typename Queue::size_type size_type;

// Constructors/Assignment/Destructors

queue_adaptor_copyable_and_movable()  {}

// Modifiers
    void close() { queue.close(); }

void push(const value_type& x) { queue.push(x); }

void pull(value_type& x) { queue.pull(x); };
    // enable_if is_nothrow_copy_movable<value_type>
    value_type pull() { return queue.pull(); }

queue_op_status try_push(const value_type& x) { return queue.try_push(x); }
    queue_op_status try_pull(value_type& x)  { return queue.try_pull(x); }

queue_op_status nonblocking_push(const value_type& x) { return queue.nonblocking_push(x); }
    queue_op_status nonblocking_pull(value_type& x)  { return queue.nonblocking_pull(x); }

queue_op_status wait_push(const value_type& x) { return queue.wait_push(x); }
    queue_op_status wait_pull(value_type& x) { return queue.wait_pull(x); }

template <class Q, class T,
#if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
#if defined __GNUC__ && ! defined __clang__
#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
          bool Copyable = is_copy_constructible<T>::value,
          bool Movable = true
#else
          bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
          bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
#endif // __GNUC__
#elif defined _MSC_VER
#if _MSC_VER < 1700
          bool Copyable = is_copy_constructible<T>::value,
          bool Movable = true
#else
          bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
          bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
#endif // _MSC_VER
#else
          bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
          bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
#endif
#else
          bool Copyable = is_copy_constructible<T>::value,
          bool Movable = has_move_emulation_enabled<T>::value
#endif
      >
  struct queue_adaptor;

template <class Q, class T>
  struct queue_adaptor<Q, T, true, true> {
    typedef queue_adaptor_copyable_and_movable<Q> type;
  };
  template <class Q, class T>
  struct queue_adaptor<Q, T, true, false> {
    typedef queue_adaptor_copyable_only<Q> type;
  };
  template <class Q, class T>
  struct queue_adaptor<Q, T, false, true> {
    typedef queue_adaptor_movable_only<Q> type;
  };

}

template <typename Queue>
  class queue_adaptor :
    public detail::queue_adaptor<Queue, typename Queue::value_type>::type
  {
  public:
      typedef typename Queue::value_type value_type;
      typedef typename Queue::size_type size_type;
    // Constructors/Assignment/Destructors
    virtual ~queue_adaptor() {};
  };
}
using concurrent::queue_adaptor;

}

#include <boost/config/abi_suffix.hpp>

#endif

#ifndef BOOST_THREAD_QUEUE_ADAPTOR_HPP #define BOOST_THREAD_QUEUE_ADAPTOR_HPP ////////////////////////////////////////////////////////////////////////////// // // (C) Copyright Vicente J. Botet Escriba 2014. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/thread for documentation. // ////////////////////////////////////////////////////////////////////////////// #include #include #include #include #include namespace boost { namespace concurrent { namespace detail { template class queue_adaptor_copyable_only : public boost::queue_base { Queue queue; public: typedef typename Queue::value_type value_type; typedef typename Queue::size_type size_type; // Constructors/Assignment/Destructors queue_adaptor_copyable_only() {} // Observers bool empty() const { return queue.empty(); } bool full() const { return queue.full(); } size_type size() const { return queue.size(); } bool closed() const { return queue.closed(); } // Modifiers void close() { queue.close(); } void push(const value_type& x) { queue.push(x); } void pull(value_type& x) { queue.pull(x); }; value_type pull() { return queue.pull(); } queue_op_status try_push(const value_type& x) { return queue.try_push(x); } queue_op_status try_pull(value_type& x) { return queue.try_pull(x); } queue_op_status nonblocking_push(const value_type& x) { return queue.nonblocking_push(x); } queue_op_status nonblocking_pull(value_type& x) { return queue.nonblocking_pull(x); } queue_op_status wait_push(const value_type& x) { return queue.wait_push(x); } queue_op_status wait_pull(value_type& x) { return queue.wait_pull(x); } }; template class queue_adaptor_movable_only : public boost::queue_base { Queue queue; public: typedef typename Queue::value_type value_type; typedef typename Queue::size_type size_type; // Constructors/Assignment/Destructors queue_adaptor_movable_only() {} // Observers bool empty() const { return queue.empty(); } bool full() const { return queue.full(); } size_type size() const { return queue.size(); } bool closed() const { return queue.closed(); } // Modifiers void close() { queue.close(); } void pull(value_type& x) { queue.pull(x); }; // enable_if is_nothrow_copy_movable value_type pull() { return queue.pull(); } queue_op_status try_pull(value_type& x) { return queue.try_pull(x); } queue_op_status nonblocking_pull(value_type& x) { return queue.nonblocking_pull(x); } queue_op_status wait_pull(value_type& x) { return queue.wait_pull(x); } void push(BOOST_THREAD_RV_REF(value_type) x) { queue.push(boost::move(x)); } queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) { return queue.try_push(boost::move(x)); } queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) { return queue.nonblocking_push(boost::move(x)); } queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x) { return queue.wait_push(boost::move(x)); } }; template class queue_adaptor_copyable_and_movable : public boost::queue_base { Queue queue; public: typedef typename Queue::value_type value_type; typedef typename Queue::size_type size_type; // Constructors/Assignment/Destructors queue_adaptor_copyable_and_movable() {} // Observers bool empty() const { return queue.empty(); } bool full() const { return queue.full(); } size_type size() const { return queue.size(); } bool closed() const { return queue.closed(); } // Modifiers void close() { queue.close(); } void push(const value_type& x) { queue.push(x); } void pull(value_type& x) { queue.pull(x); }; // enable_if is_nothrow_copy_movable value_type pull() { return queue.pull(); } queue_op_status try_push(const value_type& x) { return queue.try_push(x); } queue_op_status try_pull(value_type& x) { return queue.try_pull(x); } queue_op_status nonblocking_push(const value_type& x) { return queue.nonblocking_push(x); } queue_op_status nonblocking_pull(value_type& x) { return queue.nonblocking_pull(x); } queue_op_status wait_push(const value_type& x) { return queue.wait_push(x); } queue_op_status wait_pull(value_type& x) { return queue.wait_pull(x); } void push(BOOST_THREAD_RV_REF(value_type) x) { queue.push(boost::move(x)); } queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) { return queue.try_push(boost::move(x)); } queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) { return queue.nonblocking_push(boost::move(x)); } queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x) { return queue.wait_push(boost::move(x)); } }; template ::value, bool Movable = true #else bool Copyable = std::is_copy_constructible::value && std::is_copy_assignable::value, bool Movable = std::is_move_constructible::value && std::is_move_assignable::value #endif // __GNUC__ #elif defined _MSC_VER #if _MSC_VER < 1700 bool Copyable = is_copy_constructible::value, bool Movable = true #else bool Copyable = std::is_copy_constructible::value && std::is_copy_assignable::value, bool Movable = std::is_move_constructible::value && std::is_move_assignable::value #endif // _MSC_VER #else bool Copyable = std::is_copy_constructible::value && std::is_copy_assignable::value, bool Movable = std::is_move_constructible::value && std::is_move_assignable::value #endif #else bool Copyable = is_copy_constructible::value, bool Movable = has_move_emulation_enabled::value #endif > struct queue_adaptor; template struct queue_adaptor { typedef queue_adaptor_copyable_and_movable type; }; template struct queue_adaptor { typedef queue_adaptor_copyable_only type; }; template struct queue_adaptor { typedef queue_adaptor_movable_only type; }; } template class queue_adaptor : public detail::queue_adaptor::type { public: typedef typename Queue::value_type value_type; typedef typename Queue::size_type size_type; // Constructors/Assignment/Destructors virtual ~queue_adaptor() {}; }; } using concurrent::queue_adaptor; } #include #endif