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
queue_back_view(Queue & q)35     queue_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(x); }
47 
try_push(const value_type & x)48     queue_op_status try_push(const value_type& x) { return queue->try_push(x); }
49 
nonblocking_push(const value_type & x)50     queue_op_status nonblocking_push(const value_type& x) { return queue->nonblocking_push(x); }
wait_push(const value_type & x)51     queue_op_status wait_push(const value_type& x) { return queue->wait_push(x); }
52 
push(BOOST_THREAD_RV_REF (value_type)x)53     void push(BOOST_THREAD_RV_REF(value_type) x) { queue->push(boost::move(x)); }
try_push(BOOST_THREAD_RV_REF (value_type)x)54     queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->try_push(boost::move(x)); }
nonblocking_push(BOOST_THREAD_RV_REF (value_type)x)55     queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) { return queue->nonblocking_push(boost::move(x)); }
wait_push(BOOST_THREAD_RV_REF (value_type)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
queue_front_view(Queue & q)68     queue_front_view(Queue& q) BOOST_NOEXCEPT : queue(&q) {}
69 
70     // Observers
empty() const71     bool empty() const  { return queue->empty(); }
full() const72     bool full() const { return queue->full(); }
size() const73     size_type size() const { return queue->size(); }
closed() const74     bool closed() const { return queue->closed(); }
75 
76     // Modifiers
close()77     void close() { queue->close(); }
78 
pull(value_type & x)79     void pull(value_type& x) { queue->pull(x); };
80     // enable_if is_nothrow_copy_movable<value_type>
pull()81     value_type pull()  { return queue->pull(); }
82 
try_pull(value_type & x)83     queue_op_status try_pull(value_type& x) { return queue->try_pull(x); }
84 
nonblocking_pull(value_type & x)85     queue_op_status nonblocking_pull(value_type& x) { return queue->nonblocking_pull(x); }
86 
wait_pull(value_type & x)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;
queue_backboost::concurrent::queue_back104     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;
queue_frontboost::concurrent::queue_front110     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
145