MIDI2LR 6.1.0.0
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 , class = std::enable_if_t<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 , class = std::enable_if_t<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 , class = std::enable_if_t<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 , class = std::enable_if_t<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 , class = std::enable_if_t<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:284

◆ 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
55 {
56 auto lock {std::scoped_lock(other.mutex_)};
57 queue_ = other.queue_;
58 }

◆ 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
62 {
63 auto lock {std::scoped_lock(other.mutex_)};
64 queue_ = std::exchange(other.queue_, {});
65 }

◆ ConcurrentQueue() [6/10]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
template<class Alloc , class = std::enable_if_t<std::uses_allocator_v<Container, Alloc>>>
rsj::ConcurrentQueue< T, Container, Mutex >::ConcurrentQueue ( const Alloc &  alloc)
inlineexplicitnoexcept
70 : queue_ {alloc}
71 {
72 }

◆ ConcurrentQueue() [7/10]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
template<class Alloc , class = std::enable_if_t<std::uses_allocator_v<Container, Alloc>>>
rsj::ConcurrentQueue< T, Container, Mutex >::ConcurrentQueue ( const Container &  cont,
const Alloc &  alloc 
)
inline
75 : queue_ {cont, alloc}
76 {
77 }

◆ ConcurrentQueue() [8/10]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
template<class Alloc , class = std::enable_if_t<std::uses_allocator_v<Container, Alloc>>>
rsj::ConcurrentQueue< T, Container, Mutex >::ConcurrentQueue ( Container &&  cont,
const Alloc &  alloc 
)
inlinenoexcept
82 : queue_(std::exchange(cont, {}), alloc)
83 {
84 }

◆ ConcurrentQueue() [9/10]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
template<class Alloc , class = std::enable_if_t<std::uses_allocator_v<Container, Alloc>>>
rsj::ConcurrentQueue< T, Container, Mutex >::ConcurrentQueue ( const ConcurrentQueue< T, Container, Mutex > &  other,
const Alloc &  alloc 
)
inline
87 : queue_(alloc)
88 {
89 auto lock {std::scoped_lock(other.mutex_)};
90 queue_ = Container(other.queue_, alloc);
91 }

◆ ConcurrentQueue() [10/10]

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
template<class Alloc , class = std::enable_if_t<std::uses_allocator_v<Container, Alloc>>>
rsj::ConcurrentQueue< T, Container, Mutex >::ConcurrentQueue ( ConcurrentQueue< T, Container, Mutex > &&  other,
const Alloc &  alloc 
)
inlinenoexcept
98 : queue_(alloc)
99 {
100 auto lock {std::scoped_lock(other.mutex_)};
101 queue_ = Container(std::exchange(other.queue_, {}), alloc);
102 }

◆ ~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
227 { /*https://devblogs.microsoft.com/oldnewthing/20201112-00/?p=104444 */
228 Container trash {};
229 auto lock {std::scoped_lock(mutex_)};
230 std::swap(trash, queue_);
231 }
rsj::ConcurrentQueue::mutex_
Mutex mutex_
Definition Concurrency.h:288

◆ clear_count()

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
size_type rsj::ConcurrentQueue< T, Container, Mutex >::clear_count ( )
inlinenoexcept
237 {
238 Container trash {};
239 {
240 auto lock {std::scoped_lock(mutex_)};
241 std::swap(trash, queue_);
242 }
243 return trash.size();
244 }

◆ 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
271 {
272 Container trash {};
273 {
274 T new_item {std::forward<Args>(args)...};
275 auto lock {std::scoped_lock(mutex_)};
276 std::swap(trash, queue_);
277 queue_.push_back(std::move(new_item));
278 }
279 condition_.notify_one();
280 return trash.size();
281 }
rsj::ConcurrentQueue::condition_
std::conditional_t< std::is_same_v< Mutex, std::mutex >, std::condition_variable, std::condition_variable_any > condition_
Definition Concurrency.h:287

◆ 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
247 {
248 Container trash {};
249 {
250 auto lock {std::scoped_lock(mutex_)};
251 std::swap(trash, queue_);
252 queue_.push_back(value);
253 }
254 condition_.notify_one();
255 return trash.size();
256 }

◆ 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
259 {
260 Container trash {};
261 {
262 auto lock {std::scoped_lock(mutex_)};
263 std::swap(trash, queue_);
264 queue_.push_back(std::move(value));
265 }
266 condition_.notify_one();
267 return trash.size();
268 }

◆ 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
171 {
172 {
173 T new_item {std::forward<Args>(args)...};
174 auto lock {std::scoped_lock(mutex_)};
175 queue_.push_back(std::move(new_item));
176 }
177 condition_.notify_one();
178 }

◆ empty()

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
auto rsj::ConcurrentQueue< T, Container, Mutex >::empty ( ) const
inlinenoexcept
133 {
134 auto lock {std::scoped_lock(mutex_)};
135 return queue_.empty();
136 }

◆ 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
147 {
148 auto lock {std::scoped_lock(mutex_)};
149 return queue_.max_size();
150 }

◆ 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
118 {
119 {
120 auto lock {std::scoped_lock(mutex_, other.mutex_)};
121 queue_ = std::exchange(other.queue_, {});
122 }
123 condition_.notify_all();
124 return *this;
125 }

◆ 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
107 {
108 {
109 auto lock {std::scoped_lock(mutex_, other.mutex_)};
110 queue_ = other.queue_;
111 }
112 condition_.notify_all();
113 return *this;
114 }

◆ pop()

template<typename T , class Container = std::deque<T>, class Mutex = std::mutex>
T rsj::ConcurrentQueue< T, Container, Mutex >::pop ( )
inline
181 {
182 auto lock {std::unique_lock(mutex_)};
183 while (queue_.empty()) { condition_.wait(lock); }
184 T rc {std::move(queue_.front())};
185 queue_.pop_front();
186 return rc;
187 }

◆ 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
153 {
154 {
155 auto lock {std::scoped_lock(mutex_)};
156 queue_.push_back(value);
157 }
158 condition_.notify_one();
159 }

◆ 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
162 {
163 {
164 auto lock {std::scoped_lock(mutex_)};
165 queue_.push_back(std::move(value));
166 }
167 condition_.notify_one();
168 }

◆ 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
210 {
211 auto lock {std::scoped_lock(mutex_)};
212 queue_.resize(count);
213 }

◆ 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
216 {
217 {
218 auto lock {std::scoped_lock(mutex_)};
219 queue_.resize(count, value);
220 }
221 condition_.notify_all();
222 }

◆ size()

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

◆ 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
200 {
201 {
202 auto lock {std::scoped_lock(mutex_, other.mutex_)};
203 queue_.swap(other.queue_);
204 }
205 condition_.notify_all();
206 other.condition_.notify_all();
207 }

◆ 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
190 {
191 auto lock {std::scoped_lock(mutex_)};
192 if (queue_.empty()) { return std::nullopt; }
193 T rc {std::move(queue_.front())};
194 queue_.pop_front();
195 return rc;
196 }

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
287{};

◆ mutex_

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

◆ queue_

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