ceph/src/boost/libs/thread/include/boost/thread/concurrent_queues/deque_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/deque_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 deque_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     deque_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_back(x); }
  47
  48     void pull(value_type& x) { queue->pull_back(x); }
  49     // enable_if is_nothrow_copy_movable<value_type>
  50     value_type pull()  { return queue->pull_back(); }
  51
  52     queue_op_status try_push(const value_type& x) { return queue->try_push_back(x); }
  53
  54     queue_op_status try_pull(value_type& x) { return queue->try_pull_back(x); }
  55
  56     queue_op_status nonblocking_push(const value_type& x) { return queue->nonblocking_push_back(x); }
  57
  58     queue_op_status nonblocking_pull(value_type& x) { return queue->nonblocking_pull_back(x); }
  59
  60     queue_op_status wait_push(const value_type& x) { return queue->wait_push_back(x); }
  61     queue_op_status wait_pull(value_type& x) { return queue->wait_pull_back(x); }
  62
  63     void push(BOOST_THREAD_RV_REF(value_type) x) { queue->push_back(boost::move(x)); }
  64     queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->try_push_back(boost::move(x)); }
  65     queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->nonblocking_push_back(boost::move(x)); }
  66     queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->wait_push_back(boost::move(x)); }
  67   };
  68
  69   template <typename Queue>
  70   class deque_front_view
  71   {
  72    Queue* queue;
  73   public:
  74     typedef typename Queue::value_type value_type;
  75     typedef typename Queue::size_type size_type;
  76
  77     // Constructors/Assignment/Destructors
  78     deque_front_view(Queue& q) BOOST_NOEXCEPT : queue(&q) {}
  79
  80     // Observers
  81     bool empty() const  { return queue->empty(); }
  82     bool full() const { return queue->full(); }
  83     size_type size() const { return queue->size(); }
  84     bool closed() const { return queue->closed(); }
  85
  86     // Modifiers
  87     void close() { queue->close(); }
  88
  89     void push(const value_type& x) { queue->push_front(x); }
  90
  91     void pull(value_type& x) { queue->pull_front(x); };
  92     // enable_if is_nothrow_copy_movable<value_type>
  93     value_type pull()  { return queue->pull_front(); }
  94
  95     queue_op_status try_push(const value_type& x) { return queue->try_push_front(x); }
  96
  97     queue_op_status try_pull(value_type& x) { return queue->try_pull_front(x); }
  98
  99     queue_op_status nonblocking_push(const value_type& x) { return queue->nonblocking_push_front(x); }
 100
 101     queue_op_status nonblocking_pull(value_type& x) { return queue->nonblocking_pull_front(x); }
 102
 103     queue_op_status wait_push(const value_type& x) { return queue->wait_push_front(x); }
 104     queue_op_status wait_pull(value_type& x) { return queue->wait_pull_front(x); }
 105     void push(BOOST_THREAD_RV_REF(value_type) x) { queue->push_front(forward<value_type>(x)); }
 106     queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->try_push_front(forward<value_type>(x)); }
 107     queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->nonblocking_push_front(forward<value_type>(x)); }
 108     queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->wait_push_front(forward<value_type>(x)); }
 109
 110   };
 111
 112 #if ! defined BOOST_NO_CXX11_TEMPLATE_ALIASES
 113
 114   template <class T>
 115   using deque_back = deque_back_view<deque_base<T> > ;
 116   template <class T>
 117   using deque_front = deque_front_view<deque_base<T> > ;
 118
 119 #else
 120
 121   template <class T>
 122   struct deque_back : deque_back_view<deque_base<T> >
 123   {
 124     typedef deque_back_view<deque_base<T> > base_type;
 125     deque_back(deque_base<T>& q) BOOST_NOEXCEPT : base_type(q) {}
 126   };
 127   template <class T>
 128   struct deque_front : deque_front_view<deque_base<T> >
 129   {
 130     typedef deque_front_view<deque_base<T> > base_type;
 131     deque_front(deque_base<T>& q) BOOST_NOEXCEPT : base_type(q) {}
 132
 133   };
 134
 135 #endif
 136
 137 //  template <class Queue>
 138 //  deque_back_view<Queue> back(Queue & q) { return deque_back_view<Queue>(q); }
 139 //  template <class Queue>
 140 //  deque_front_view<Queue> front(Queue & q) { return deque_front_view<Queue>(q); }
 141 //#if 0
 142 //  template <class T>
 143 //  deque_back<T> back(deque_base<T> & q) { return deque_back<T>(q); }
 144 //  template <class T>
 145 //  deque_front<T> front(deque_base<T> & q) { return deque_front<T>(q); }
 146 //#else
 147 //  template <class T>
 148 //  typename deque_back<T>::type back(deque_base<T> & q) { return typename deque_back<T>::type(q); }
 149 //  template <class T>
 150 //  typename deque_front<T>::type front(deque_base<T> & q) { return typename deque_front<T>::type(q); }
 151 //#endif
 152 }
 153
 154 using concurrent::deque_back_view;
 155 using concurrent::deque_front_view;
 156 using concurrent::deque_back;
 157 using concurrent::deque_front;
 158 //using concurrent::back;
 159 //using concurrent::front;
 160
 161 }
 162
 163 #include <boost/config/abi_suffix.hpp>
 164
 165 #endif