ceph/src/boost/boost/thread/concurrent_queues/queue_views.hpp

   1 #ifndef BOOST_THREAD_QUEUE_VIEWS_HPP
   2 #define BOOST_THREAD_QUEUE_VIEWS_HPP
   3
   4 //////////////////////////////////////////////////////////////////////////////
   5 //
   6 // (C) Copyright Vicente J. Botet Escriba 2014. Distributed under the Boost
   7 // Software License, Version 1.0. (See accompanying file
   8 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9 //
  10 // See http://www.boost.org/libs/thread for documentation.
  11 //
  12 //////////////////////////////////////////////////////////////////////////////
  13
  14 #include <boost/thread/detail/config.hpp>
  15 #include <boost/thread/detail/move.hpp>
  16 #include <boost/thread/concurrent_queues/queue_op_status.hpp>
  17 #include <boost/thread/concurrent_queues/queue_base.hpp>
  18
  19 #include <boost/config/abi_prefix.hpp>
  20
  21 namespace boost
  22 {
  23 namespace concurrent
  24 {
  25
  26   template <typename Queue>
  27   class queue_back_view
  28   {
  29    Queue* queue;
  30   public:
  31     typedef typename Queue::value_type value_type;
  32     typedef typename Queue::size_type size_type;
  33
  34     // Constructors/Assignment/Destructors
  35     queue_back_view(Queue& q) BOOST_NOEXCEPT : queue(&q) {}
  36
  37     // Observers
  38     bool empty() const  { return queue->empty(); }
  39     bool full() const { return queue->full(); }
  40     size_type size() const { return queue->size(); }
  41     bool closed() const { return queue->closed(); }
  42
  43     // Modifiers
  44     void close() { queue->close(); }
  45
  46     void push(const value_type& x) { queue->push(x); }
  47
  48     queue_op_status try_push(const value_type& x) { return queue->try_push(x); }
  49
  50     queue_op_status nonblocking_push(const value_type& x) { return queue->nonblocking_push(x); }
  51     queue_op_status wait_push(const value_type& x) { return queue->wait_push(x); }
  52
  53     void push(BOOST_THREAD_RV_REF(value_type) x) { queue->push(boost::move(x)); }
  54     queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->try_push(boost::move(x)); }
  55     queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->nonblocking_push(boost::move(x)); }
  56     queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->wait_push(boost::move(x)); }
  57   };
  58
  59   template <typename Queue>
  60   class queue_front_view
  61   {
  62    Queue* queue;
  63   public:
  64     typedef typename Queue::value_type value_type;
  65     typedef typename Queue::size_type size_type;
  66
  67     // Constructors/Assignment/Destructors
  68     queue_front_view(Queue& q) BOOST_NOEXCEPT : queue(&q) {}
  69
  70     // Observers
  71     bool empty() const  { return queue->empty(); }
  72     bool full() const { return queue->full(); }
  73     size_type size() const { return queue->size(); }
  74     bool closed() const { return queue->closed(); }
  75
  76     // Modifiers
  77     void close() { queue->close(); }
  78
  79     void pull(value_type& x) { queue->pull(x); };
  80     // enable_if is_nothrow_copy_movable<value_type>
  81     value_type pull()  { return queue->pull(); }
  82
  83     queue_op_status try_pull(value_type& x) { return queue->try_pull(x); }
  84
  85     queue_op_status nonblocking_pull(value_type& x) { return queue->nonblocking_pull(x); }
  86
  87     queue_op_status wait_pull(value_type& x) { return queue->wait_pull(x); }
  88
  89   };
  90
  91 #if ! defined BOOST_NO_CXX11_TEMPLATE_ALIASES
  92
  93   template <class T>
  94   using queue_back = queue_back_view<queue_base<T> > ;
  95   template <class T>
  96   using queue_front = queue_front_view<queue_base<T> > ;
  97
  98 #else
  99
 100   template <class T>
 101   struct queue_back : queue_back_view<queue_base<T> >
 102   {
 103     typedef queue_back_view<queue_base<T> > base_type;
 104     queue_back(queue_base<T>& q) BOOST_NOEXCEPT : base_type(q) {}
 105   };
 106   template <class T>
 107   struct queue_front : queue_front_view<queue_base<T> >
 108   {
 109     typedef queue_front_view<queue_base<T> > base_type;
 110     queue_front(queue_base<T>& q) BOOST_NOEXCEPT : base_type(q) {}
 111
 112   };
 113
 114 #endif
 115
 116 //  template <class Queue>
 117 //  queue_back_view<Queue> back(Queue & q) { return queue_back_view<Queue>(q); }
 118 //  template <class Queue>
 119 //  queue_front_view<Queue> front(Queue & q) { return queue_front_view<Queue>(q); }
 120 //#if 0
 121 //  template <class T>
 122 //  queue_back<T> back(queue_base<T> & q) { return queue_back<T>(q); }
 123 //  template <class T>
 124 //  queue_front<T> front(queue_base<T> & q) { return queue_front<T>(q); }
 125 //#else
 126 //  template <class T>
 127 //  typename queue_back<T>::type back(queue_base<T> & q) { return typename queue_back<T>::type(q); }
 128 //  template <class T>
 129 //  typename queue_front<T>::type front(queue_base<T> & q) { return typename queue_front<T>::type(q); }
 130 //#endif
 131 }
 132
 133 using concurrent::queue_back_view;
 134 using concurrent::queue_front_view;
 135 using concurrent::queue_back;
 136 using concurrent::queue_front;
 137 //using concurrent::back;
 138 //using concurrent::front;
 139
 140 }
 141
 142 #include <boost/config/abi_suffix.hpp>
 143
 144 #endif