MIDI2LR 6.2.0.1
MIDI2LR is an application that interfaces MIDI controllers with Lightroom 6+/CC Classic. It processes MIDI input into develop parameter updates and photo actions, and sends MIDI output when parameters are changed for motorized feedback (on controllers that have motorized faders). A listing of available LightRoom commands is in the Wiki. Assistance on the code and design is welcome.
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Private Attributes | List of all members
rsj::ConcurrentQueue< T, Container, Mutex > Class Template Reference

#include <Concurrency.h>

Public Types

using const_reference = typename Container::const_reference
 
using container_type = Container
 
using reference = typename Container::reference
 
using size_type = typename Container::size_type
 
using value_type = typename Container::value_type
 

Public Member Functions

 ConcurrentQueue () noexcept(std::is_nothrow_default_constructible_v< Container >)=default
 
 ConcurrentQueue (ConcurrentQueue &&other) noexcept(std::is_nothrow_move_constructible_v< Container > &&noexcept(std::scoped_lock(mutex_)))
 
template<class Alloc >
requires (std::uses_allocator_v<Container, Alloc>)
 ConcurrentQueue (ConcurrentQueue &&other, const Alloc &alloc) noexcept(std::is_nothrow_constructible_v< Container, Container, const Alloc & > &&noexcept(std::scoped_lock(mutex_)))
 
template<class Alloc >
requires (std::uses_allocator_v<Container, Alloc>)
 ConcurrentQueue (const Alloc &alloc) noexcept(std::is_nothrow_constructible_v< Container, const Alloc & >)
 
 ConcurrentQueue (const ConcurrentQueue &other) noexcept(std::is_nothrow_copy_constructible_v< Container > &&noexcept(std::scoped_lock(mutex_)))
 
template<class Alloc >
requires (std::uses_allocator_v<Container, Alloc>)
 ConcurrentQueue (const ConcurrentQueue &other, const Alloc &alloc)
 
 ConcurrentQueue (const Container &cont) noexcept(std::is_nothrow_copy_constructible_v< Container >)
 
template<class Alloc >
requires (std::uses_allocator_v<Container, Alloc>)
 ConcurrentQueue (const Container &cont, const Alloc &alloc)
 
 ConcurrentQueue (Container &&cont) noexcept(std::is_nothrow_move_constructible_v< Container >)
 
template<class Alloc >
requires (std::uses_allocator_v<Container, Alloc>)
 ConcurrentQueue (Container &&cont, const Alloc &alloc) noexcept(std::is_nothrow_constructible_v< Container, Container, const Alloc & >)
 
 ~ConcurrentQueue ()=default
 
void clear () noexcept(std::is_nothrow_default_constructible_v< Container > &&std::is_nothrow_destructible_v< Container > &&std::is_nothrow_swappable_v< Container > &&noexcept(std::scoped_lock(mutex_)))
 
size_type clear_count () noexcept(std::is_nothrow_default_constructible_v< Container > &&std::is_nothrow_destructible_v< Container > &&std::is_nothrow_swappable_v< Container > &&noexcept(queue_.size()) &&noexcept(std::scoped_lock(mutex_)))
 
template<class... Args>
auto clear_count_emplace (Args &&... args)
 
size_type clear_count_push (const T &value)
 
size_type clear_count_push (T &&value)
 
template<class... Args>
void emplace (Args &&... args)
 
auto empty () const noexcept(noexcept(queue_.empty()) &&noexcept(std::scoped_lock(mutex_)))
 
size_type max_size () const noexcept(noexcept(queue_.max_size()) &&noexcept(std::scoped_lock(mutex_)))
 
ConcurrentQueue & operator= (ConcurrentQueue &&other) noexcept(std::is_nothrow_move_assignable_v< Container > &&noexcept(std::scoped_lock(mutex_)))
 
ConcurrentQueue & operator= (const ConcurrentQueue &other) noexcept(std::is_nothrow_copy_assignable_v< Container > &&noexcept(std::scoped_lock(mutex_)))
 
T pop ()
 
void push (const T &value)
 
void push (T &&value)
 
void resize (size_type count)
 
void resize (size_type count, const value_type &value)
 
size_type size () const noexcept(noexcept(queue_.size()) &&noexcept(std::scoped_lock(mutex_)))
 
void swap (ConcurrentQueue &other) noexcept(std::is_nothrow_swappable_v< Container > &&noexcept(std::scoped_lock(mutex_)))
 
std::optional< T > try_pop ()
 

Private Attributes

std::conditional_t< std::is_same_v< Mutex, std::mutex >, std::condition_variable, std::condition_variable_any > condition_ {}
 
Mutex mutex_ {}
 
Container queue_ {}
 

Member Typedef Documentation

◆ const_reference

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
using rsj::ConcurrentQueue< T, Container, Mutex >::const_reference = typename Container::const_reference

◆ container_type

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
using rsj::ConcurrentQueue< T, Container, Mutex >::container_type = Container

◆ reference

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
using rsj::ConcurrentQueue< T, Container, Mutex >::reference = typename Container::reference

◆ size_type

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
using rsj::ConcurrentQueue< T, Container, Mutex >::size_type = typename Container::size_type

◆ value_type

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
using rsj::ConcurrentQueue< T, Container, Mutex >::value_type = typename Container::value_type

Constructor & Destructor Documentation

◆ ConcurrentQueue() [1/10]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
rsj::ConcurrentQueue< T, Container, Mutex >::ConcurrentQueue ( ) const
defaultnoexcept

◆ ConcurrentQueue() [2/10]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
rsj::ConcurrentQueue< T, Container, Mutex >::ConcurrentQueue ( const Container &  cont)
inlineexplicitnoexcept
43 : queue_ {cont}
44 {
45 }
rsj::ConcurrentQueue::queue_
Container queue_
Definition Concurrency.h:296

◆ ConcurrentQueue() [3/10]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
rsj::ConcurrentQueue< T, Container, Mutex >::ConcurrentQueue ( Container &&  cont)
inlineexplicitnoexcept
49 : queue_ {std::exchange(cont, {})}
50 {
51 }

◆ ConcurrentQueue() [4/10]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
rsj::ConcurrentQueue< T, Container, Mutex >::ConcurrentQueue ( const ConcurrentQueue< T, Container, Mutex > &  other)
inlinenoexcept
56 {
57 auto lock {std::scoped_lock(other.mutex_)};
58 queue_ = other.queue_;
59 }

◆ ConcurrentQueue() [5/10]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
rsj::ConcurrentQueue< T, Container, Mutex >::ConcurrentQueue ( ConcurrentQueue< T, Container, Mutex > &&  other)
inlinenoexcept
64 {
65 auto lock {std::scoped_lock(other.mutex_)};
66 queue_ = std::exchange(other.queue_, {});
67 }

◆ ConcurrentQueue() [6/10]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
template<class Alloc >
requires (std::uses_allocator_v<Container, Alloc>)
rsj::ConcurrentQueue< T, Container, Mutex >::ConcurrentQueue ( const Alloc &  alloc)
inlineexplicitnoexcept
73 : queue_ {alloc}
74 {
75 }

◆ ConcurrentQueue() [7/10]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
template<class Alloc >
requires (std::uses_allocator_v<Container, Alloc>)
rsj::ConcurrentQueue< T, Container, Mutex >::ConcurrentQueue ( const Container &  cont,
const Alloc &  alloc 
)
inline
80 : queue_ {cont, alloc}
81 {
82 }

◆ ConcurrentQueue() [8/10]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
template<class Alloc >
requires (std::uses_allocator_v<Container, Alloc>)
rsj::ConcurrentQueue< T, Container, Mutex >::ConcurrentQueue ( Container &&  cont,
const Alloc &  alloc 
)
inlinenoexcept
88 : queue_(std::exchange(cont, {}), alloc)
89 {
90 }

◆ ConcurrentQueue() [9/10]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
template<class Alloc >
requires (std::uses_allocator_v<Container, Alloc>)
rsj::ConcurrentQueue< T, Container, Mutex >::ConcurrentQueue ( const ConcurrentQueue< T, Container, Mutex > &  other,
const Alloc &  alloc 
)
inline
95 : queue_(alloc)
96 {
97 auto lock {std::scoped_lock(other.mutex_)};
98 queue_ = Container(other.queue_, alloc);
99 }

◆ ConcurrentQueue() [10/10]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
template<class Alloc >
requires (std::uses_allocator_v<Container, Alloc>)
rsj::ConcurrentQueue< T, Container, Mutex >::ConcurrentQueue ( ConcurrentQueue< T, Container, Mutex > &&  other,
const Alloc &  alloc 
)
inlinenoexcept
106 : queue_(alloc)
107 {
108 auto lock {std::scoped_lock(other.mutex_)};
109 queue_ = Container(std::exchange(other.queue_, {}), alloc);
110 }

◆ ~ConcurrentQueue()

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
rsj::ConcurrentQueue< T, Container, Mutex >::~ConcurrentQueue ( )
default

Member Function Documentation

◆ clear()

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
void rsj::ConcurrentQueue< T, Container, Mutex >::clear ( )
inlinenoexcept
238 { /*https://devblogs.microsoft.com/oldnewthing/20201112-00/?p=104444 */
239 Container trash {};
240 auto lock {std::scoped_lock(mutex_)};
241 std::swap(trash, queue_);
242 }
rsj::ConcurrentQueue::mutex_
Mutex mutex_
Definition Concurrency.h:300

◆ clear_count()

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
size_type rsj::ConcurrentQueue< T, Container, Mutex >::clear_count ( )
inlinenoexcept
249 {
250 Container trash {};
251 {
252 auto lock {std::scoped_lock(mutex_)};
253 std::swap(trash, queue_);
254 }
255 return trash.size();
256 }

◆ clear_count_emplace()

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
template<class... Args>
auto rsj::ConcurrentQueue< T, Container, Mutex >::clear_count_emplace ( Args &&...  args)
inline
283 {
284 Container trash {};
285 {
286 T new_item {std::forward<Args>(args)...};
287 auto lock {std::scoped_lock(mutex_)};
288 std::swap(trash, queue_);
289 queue_.push_back(std::move(new_item));
290 }
291 condition_.notify_one();
292 return trash.size();
293 }
rsj::ConcurrentQueue::condition_
std::conditional_t< std::is_same_v< Mutex, std::mutex >, std::condition_variable, std::condition_variable_any > condition_
Definition Concurrency.h:299

◆ clear_count_push() [1/2]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
size_type rsj::ConcurrentQueue< T, Container, Mutex >::clear_count_push ( const T &  value)
inline
259 {
260 Container trash {};
261 {
262 auto lock {std::scoped_lock(mutex_)};
263 std::swap(trash, queue_);
264 queue_.push_back(value);
265 }
266 condition_.notify_one();
267 return trash.size();
268 }

◆ clear_count_push() [2/2]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
size_type rsj::ConcurrentQueue< T, Container, Mutex >::clear_count_push ( T &&  value)
inline
271 {
272 Container trash {};
273 {
274 auto lock {std::scoped_lock(mutex_)};
275 std::swap(trash, queue_);
276 queue_.push_back(std::move(value));
277 }
278 condition_.notify_one();
279 return trash.size();
280 }

◆ emplace()

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
template<class... Args>
void rsj::ConcurrentQueue< T, Container, Mutex >::emplace ( Args &&...  args)
inline
181 {
182 {
183 T new_item {std::forward<Args>(args)...};
184 auto lock {std::scoped_lock(mutex_)};
185 queue_.push_back(std::move(new_item));
186 }
187 condition_.notify_one();
188 }

◆ empty()

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
auto rsj::ConcurrentQueue< T, Container, Mutex >::empty ( ) const
inlinenoexcept
143 {
144 auto lock {std::scoped_lock(mutex_)};
145 return queue_.empty();
146 }

◆ max_size()

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
size_type rsj::ConcurrentQueue< T, Container, Mutex >::max_size ( ) const
inlinenoexcept
157 {
158 auto lock {std::scoped_lock(mutex_)};
159 return queue_.max_size();
160 }

◆ operator=() [1/2]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
ConcurrentQueue & rsj::ConcurrentQueue< T, Container, Mutex >::operator= ( ConcurrentQueue< T, Container, Mutex > &&  other)
inlinenoexcept
128 {
129 {
130 auto lock {std::scoped_lock(mutex_, other.mutex_)};
131 queue_ = std::exchange(other.queue_, {});
132 }
133 condition_.notify_all();
134 return *this;
135 }

◆ operator=() [2/2]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
ConcurrentQueue & rsj::ConcurrentQueue< T, Container, Mutex >::operator= ( const ConcurrentQueue< T, Container, Mutex > &  other)
inlinenoexcept
116 {
117 {
118 auto lock {std::scoped_lock(mutex_, other.mutex_)};
119 queue_ = other.queue_;
120 }
121 condition_.notify_all();
122 return *this;
123 }

◆ pop()

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
T rsj::ConcurrentQueue< T, Container, Mutex >::pop ( )
inline
191 {
192 auto lock {std::unique_lock(mutex_)};
193 while (queue_.empty()) { condition_.wait(lock); }
194 T rc {std::move(queue_.front())};
195 queue_.pop_front();
196 return rc;
197 }

◆ push() [1/2]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
void rsj::ConcurrentQueue< T, Container, Mutex >::push ( const T &  value)
inline
163 {
164 {
165 auto lock {std::scoped_lock(mutex_)};
166 queue_.push_back(value);
167 }
168 condition_.notify_one();
169 }

◆ push() [2/2]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
void rsj::ConcurrentQueue< T, Container, Mutex >::push ( T &&  value)
inline
172 {
173 {
174 auto lock {std::scoped_lock(mutex_)};
175 queue_.push_back(std::move(value));
176 }
177 condition_.notify_one();
178 }

◆ resize() [1/2]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
void rsj::ConcurrentQueue< T, Container, Mutex >::resize ( size_type  count)
inline
220 {
221 auto lock {std::scoped_lock(mutex_)};
222 queue_.resize(count);
223 }

◆ resize() [2/2]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
void rsj::ConcurrentQueue< T, Container, Mutex >::resize ( size_type  count,
const value_type &  value 
)
inline
226 {
227 {
228 auto lock {std::scoped_lock(mutex_)};
229 queue_.resize(count, value);
230 }
231 condition_.notify_all();
232 }

◆ size()

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
size_type rsj::ConcurrentQueue< T, Container, Mutex >::size ( ) const
inlinenoexcept
150 {
151 auto lock {std::scoped_lock(mutex_)};
152 return queue_.size();
153 }

◆ swap()

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
void rsj::ConcurrentQueue< T, Container, Mutex >::swap ( ConcurrentQueue< T, Container, Mutex > &  other)
inlinenoexcept
210 {
211 {
212 auto lock {std::scoped_lock(mutex_, other.mutex_)};
213 queue_.swap(other.queue_);
214 }
215 condition_.notify_all();
216 other.condition_.notify_all();
217 }

◆ try_pop()

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
std::optional< T > rsj::ConcurrentQueue< T, Container, Mutex >::try_pop ( )
inline
200 {
201 auto lock {std::scoped_lock(mutex_)};
202 if (queue_.empty()) { return std::nullopt; }
203 T rc {std::move(queue_.front())};
204 queue_.pop_front();
205 return rc;
206 }

Member Data Documentation

◆ condition_

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
std::conditional_t<std::is_same_v<Mutex, std::mutex>, std::condition_variable, std::condition_variable_any> rsj::ConcurrentQueue< T, Container, Mutex >::condition_ {}
mutableprivate
299{};

◆ mutex_

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
Mutex rsj::ConcurrentQueue< T, Container, Mutex >::mutex_ {}
mutableprivate
300{};

◆ queue_

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
Container rsj::ConcurrentQueue< T, Container, Mutex >::queue_ {}
private
296{};
The documentation for this class was generated from the following file: