1 #ifndef BOOST_THREAD_CONCURRENT_QUEUES_DETAIL_SYNC_QUEUE_BASE_HPP
2 #define BOOST_THREAD_CONCURRENT_QUEUES_DETAIL_SYNC_QUEUE_BASE_HPP
4 //////////////////////////////////////////////////////////////////////////////
6 // (C) Copyright Vicente J. Botet Escriba 2013-2017. 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)
10 // See http://www.boost.org/libs/thread for documentation.
12 //////////////////////////////////////////////////////////////////////////////
14 #include <boost/thread/detail/config.hpp>
15 #include <boost/thread/condition_variable.hpp>
16 #include <boost/thread/detail/move.hpp>
17 #include <boost/thread/mutex.hpp>
18 #include <boost/thread/concurrent_queues/queue_op_status.hpp>
20 #include <boost/chrono/time_point.hpp>
21 #include <boost/throw_exception.hpp>
23 #include <boost/config/abi_prefix.hpp>
32 template <class ValueType, class Queue>
36 typedef ValueType value_type;
37 typedef Queue underlying_queue_type;
38 typedef typename Queue::size_type size_type;
39 typedef queue_op_status op_status;
41 // Constructors/Assignment/Destructors
42 BOOST_THREAD_NO_COPYABLE(sync_queue_base)
43 inline sync_queue_base();
44 //template <typename Range>
45 //inline explicit sync_queue(Range range);
46 inline ~sync_queue_base();
49 inline bool empty() const;
50 inline bool full() const;
51 inline size_type size() const;
52 inline bool closed() const;
57 inline underlying_queue_type underlying_queue() {
58 lock_guard<mutex> lk(mtx_);
59 return boost::move(data_);
64 condition_variable not_empty_;
65 underlying_queue_type data_;
68 inline bool empty(unique_lock<mutex>& ) const BOOST_NOEXCEPT
72 inline bool empty(lock_guard<mutex>& ) const BOOST_NOEXCEPT
77 inline size_type size(lock_guard<mutex>& ) const BOOST_NOEXCEPT
81 inline bool closed(unique_lock<mutex>& lk) const;
82 inline bool closed(lock_guard<mutex>& lk) const;
84 inline void throw_if_closed(unique_lock<mutex>&);
85 inline void throw_if_closed(lock_guard<mutex>&);
87 inline void wait_until_not_empty(unique_lock<mutex>& lk);
88 inline bool wait_until_not_empty_or_closed(unique_lock<mutex>& lk);
89 template <class WClock, class Duration>
90 queue_op_status wait_until_not_empty_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&);
92 inline void notify_not_empty_if_needed(unique_lock<mutex>& )
94 not_empty_.notify_one();
96 inline void notify_not_empty_if_needed(lock_guard<mutex>& )
98 not_empty_.notify_one();
103 template <class ValueType, class Queue>
104 sync_queue_base<ValueType, Queue>::sync_queue_base() :
105 data_(), closed_(false)
107 BOOST_ASSERT(data_.empty());
110 template <class ValueType, class Queue>
111 sync_queue_base<ValueType, Queue>::~sync_queue_base()
115 template <class ValueType, class Queue>
116 void sync_queue_base<ValueType, Queue>::close()
119 lock_guard<mutex> lk(mtx_);
122 not_empty_.notify_all();
125 template <class ValueType, class Queue>
126 bool sync_queue_base<ValueType, Queue>::closed() const
128 lock_guard<mutex> lk(mtx_);
131 template <class ValueType, class Queue>
132 bool sync_queue_base<ValueType, Queue>::closed(unique_lock<mutex>&) const
136 template <class ValueType, class Queue>
137 bool sync_queue_base<ValueType, Queue>::closed(lock_guard<mutex>&) const
142 template <class ValueType, class Queue>
143 bool sync_queue_base<ValueType, Queue>::empty() const
145 lock_guard<mutex> lk(mtx_);
148 template <class ValueType, class Queue>
149 bool sync_queue_base<ValueType, Queue>::full() const
154 template <class ValueType, class Queue>
155 typename sync_queue_base<ValueType, Queue>::size_type sync_queue_base<ValueType, Queue>::size() const
157 lock_guard<mutex> lk(mtx_);
161 template <class ValueType, class Queue>
162 void sync_queue_base<ValueType, Queue>::throw_if_closed(unique_lock<mutex>& lk)
166 BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
169 template <class ValueType, class Queue>
170 void sync_queue_base<ValueType, Queue>::throw_if_closed(lock_guard<mutex>& lk)
174 BOOST_THROW_EXCEPTION( sync_queue_is_closed() );
178 template <class ValueType, class Queue>
179 void sync_queue_base<ValueType, Queue>::wait_until_not_empty(unique_lock<mutex>& lk)
183 if (! empty(lk)) break;
188 template <class ValueType, class Queue>
189 bool sync_queue_base<ValueType, Queue>::wait_until_not_empty_or_closed(unique_lock<mutex>& lk)
193 if (! empty(lk)) break;
194 if (closed(lk)) return true;
200 template <class ValueType, class Queue>
201 template <class WClock, class Duration>
202 queue_op_status sync_queue_base<ValueType, Queue>::wait_until_not_empty_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp)
206 if (! empty(lk)) return queue_op_status::success;
208 if (not_empty_.wait_until(lk, tp) == cv_status::timeout ) return queue_op_status::timeout;
217 #include <boost/config/abi_suffix.hpp>