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
deque_back_view(Queue & q)35     deque_back_view(Queue& q) BOOST_NOEXCEPT : queue(&q) {}
36 
37     // Observers
empty() const38     bool empty() const  { return queue->empty(); }
full() const39     bool full() const { return queue->full(); }
size() const40     size_type size() const { return queue->size(); }
closed() const41     bool closed() const { return queue->closed(); }
42 
43     // Modifiers
close()44     void close() { queue->close(); }
45 
push(const value_type & x)46     void push(const value_type& x) { queue->push_back(x); }
47 
pull(value_type & x)48     void pull(value_type& x) { queue->pull_back(x); }
49     // enable_if is_nothrow_copy_movable<value_type>
pull()50     value_type pull()  { return queue->pull_back(); }
51 
try_push(const value_type & x)52     queue_op_status try_push(const value_type& x) { return queue->try_push_back(x); }
53 
try_pull(value_type & x)54     queue_op_status try_pull(value_type& x) { return queue->try_pull_back(x); }
55 
nonblocking_push(const value_type & x)56     queue_op_status nonblocking_push(const value_type& x) { return queue->nonblocking_push_back(x); }
57 
nonblocking_pull(value_type & x)58     queue_op_status nonblocking_pull(value_type& x) { return queue->nonblocking_pull_back(x); }
59 
wait_push(const value_type & x)60     queue_op_status wait_push(const value_type& x) { return queue->wait_push_back(x); }
wait_pull(value_type & x)61     queue_op_status wait_pull(value_type& x) { return queue->wait_pull_back(x); }
62 
push(BOOST_THREAD_RV_REF (value_type)x)63     void push(BOOST_THREAD_RV_REF(value_type) x) { queue->push_back(boost::move(x)); }
try_push(BOOST_THREAD_RV_REF (value_type)x)64     queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->try_push_back(boost::move(x)); }
nonblocking_push(BOOST_THREAD_RV_REF (value_type)x)65     queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->nonblocking_push_back(boost::move(x)); }
wait_push(BOOST_THREAD_RV_REF (value_type)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
deque_front_view(Queue & q)78     deque_front_view(Queue& q) BOOST_NOEXCEPT : queue(&q) {}
79 
80     // Observers
empty() const81     bool empty() const  { return queue->empty(); }
full() const82     bool full() const { return queue->full(); }
size() const83     size_type size() const { return queue->size(); }
closed() const84     bool closed() const { return queue->closed(); }
85 
86     // Modifiers
close()87     void close() { queue->close(); }
88 
push(const value_type & x)89     void push(const value_type& x) { queue->push_front(x); }
90 
pull(value_type & x)91     void pull(value_type& x) { queue->pull_front(x); };
92     // enable_if is_nothrow_copy_movable<value_type>
pull()93     value_type pull()  { return queue->pull_front(); }
94 
try_push(const value_type & x)95     queue_op_status try_push(const value_type& x) { return queue->try_push_front(x); }
96 
try_pull(value_type & x)97     queue_op_status try_pull(value_type& x) { return queue->try_pull_front(x); }
98 
nonblocking_push(const value_type & x)99     queue_op_status nonblocking_push(const value_type& x) { return queue->nonblocking_push_front(x); }
100 
nonblocking_pull(value_type & x)101     queue_op_status nonblocking_pull(value_type& x) { return queue->nonblocking_pull_front(x); }
102 
wait_push(const value_type & x)103     queue_op_status wait_push(const value_type& x) { return queue->wait_push_front(x); }
wait_pull(value_type & x)104     queue_op_status wait_pull(value_type& x) { return queue->wait_pull_front(x); }
push(BOOST_THREAD_RV_REF (value_type)x)105     void push(BOOST_THREAD_RV_REF(value_type) x) { queue->push_front(forward<value_type>(x)); }
try_push(BOOST_THREAD_RV_REF (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)); }
nonblocking_push(BOOST_THREAD_RV_REF (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)); }
wait_push(BOOST_THREAD_RV_REF (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;
deque_backboost::concurrent::deque_back125     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;
deque_frontboost::concurrent::deque_front131     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
166