31#ifndef ETL_MPMC_QUEUE_MUTEX_INCLUDED
32#define ETL_MPMC_QUEUE_MUTEX_INCLUDED
51 template <
size_t MEMORY_MODEL = etl::memory_model::MEMORY_MODEL_LARGE>
52 class queue_mpmc_mutex_base
62 size_type capacity()
const
77 queue_mpmc_mutex_base(size_type max_size_)
88 static size_type get_next_index(size_type index, size_type maximum)
92 if (index == maximum) ETL_UNLIKELY
100 size_type write_index;
101 size_type read_index;
102 size_type current_size;
103 const size_type MAX_SIZE;
108#if defined(ETL_POLYMORPHIC_MPMC_QUEUE_MUTEX) || defined(ETL_POLYMORPHIC_CONTAINERS)
110 virtual ~queue_mpmc_mutex_base()
115 ~queue_mpmc_mutex_base()
132 template <
typename T, const
size_t MEMORY_MODEL = etl::memory_model::MEMORY_MODEL_LARGE>
133 class iqueue_mpmc_mutex :
public queue_mpmc_mutex_base<MEMORY_MODEL>
137 typedef etl::queue_mpmc_mutex_base<MEMORY_MODEL> base_t;
141 typedef T value_type;
142 typedef T& reference;
143 typedef const T& const_reference;
145 typedef T&& rvalue_reference;
147 typedef typename base_t::size_type size_type;
149 using base_t::write_index;
150 using base_t::read_index;
151 using base_t::current_size;
152 using base_t::MAX_SIZE;
153 using base_t::get_next_index;
158 bool push(const_reference value)
162 bool result = push_implementation(value);
173 bool push(rvalue_reference value)
177 bool result = push_implementation(etl::move(value));
185#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT && !defined(ETL_QUEUE_MPMC_MUTEX_FORCE_CPP03_IMPLEMENTATION)
190 template <
typename ... Args>
191 bool emplace(Args&&... args)
195 bool result = emplace_implementation(etl::forward<Args>(args)...);
206 template <
typename T1>
207 bool emplace(
const T1& value1)
211 bool result = emplace_implementation(value1);
222 template <
typename T1,
typename T2>
223 bool emplace(
const T1& value1,
const T2& value2)
227 bool result = emplace_implementation(value1, value2);
238 template <
typename T1,
typename T2,
typename T3>
239 bool emplace(
const T1& value1,
const T2& value2,
const T3& value3)
243 bool result = emplace_implementation(value1, value2, value3);
254 template <
typename T1,
typename T2,
typename T3,
typename T4>
255 bool emplace(
const T1& value1,
const T2& value2,
const T3& value3,
const T4& value4)
259 bool result = emplace_implementation(value1, value2, value3, value4);
270 bool pop(reference value)
274 bool result = pop_implementation(value);
288 bool result = pop_implementation();
302 reference result = front_implementation();
312 const_reference front()
const
316 const_reference result = front_implementation();
330 while (pop_implementation())
345 size_type result = (current_size == 0);
359 size_type result = (current_size == MAX_SIZE);
369 size_type size()
const
373 size_type result = current_size;
383 size_type available()
const
387 size_type result = MAX_SIZE - current_size;
399 iqueue_mpmc_mutex(T* p_buffer_, size_type max_size_)
410 bool push_implementation(const_reference value)
412 if (current_size != MAX_SIZE)
414 ::new (&p_buffer[write_index]) T(value);
416 write_index = get_next_index(write_index, MAX_SIZE);
427#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT && !defined(ETL_QUEUE_MPMC_MUTEX_FORCE_CPP03_IMPLEMENTATION)
431 bool push_implementation(rvalue_reference value)
433 if (current_size != MAX_SIZE)
435 ::new (&p_buffer[write_index]) T(etl::move(value));
437 write_index = get_next_index(write_index, MAX_SIZE);
449#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT && !defined(ETL_QUEUE_MPMC_MUTEX_FORCE_CPP03_IMPLEMENTATION)
453 template <
typename ... Args>
454 bool emplace_implementation(Args&&... args)
456 if (current_size != MAX_SIZE)
458 ::new (&p_buffer[write_index]) T(etl::forward<Args>(args)...);
460 write_index = get_next_index(write_index, MAX_SIZE);
474 template <
typename T1>
475 bool emplace_implementation(
const T1& value1)
477 if (current_size != MAX_SIZE)
479 ::new (&p_buffer[write_index]) T(value1);
481 write_index = get_next_index(write_index, MAX_SIZE);
495 template <
typename T1,
typename T2>
496 bool emplace_implementation(
const T1& value1,
const T2& value2)
498 if (current_size != MAX_SIZE)
500 ::new (&p_buffer[write_index]) T(value1, value2);
502 write_index = get_next_index(write_index, MAX_SIZE);
516 template <
typename T1,
typename T2,
typename T3>
517 bool emplace_implementation(
const T1& value1,
const T2& value2,
const T3& value3)
519 if (current_size != MAX_SIZE)
521 ::new (&p_buffer[write_index]) T(value1, value2, value3);
523 write_index = get_next_index(write_index, MAX_SIZE);
537 template <
typename T1,
typename T2,
typename T3,
typename T4>
538 bool emplace_implementation(
const T1& value1,
const T2& value2,
const T3& value3,
const T4& value4)
540 if (current_size != MAX_SIZE)
542 ::new (&p_buffer[write_index]) T(value1, value2, value3, value4);
544 write_index = get_next_index(write_index, MAX_SIZE);
559 bool pop_implementation(reference value)
561 if (current_size == 0)
567#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT && !defined(ETL_QUEUE_LOCKABLE_FORCE_CPP03_IMPLEMENTATION)
568 value = etl::move(p_buffer[read_index]);
570 value = p_buffer[read_index];
573 p_buffer[read_index].~T();
575 read_index = get_next_index(read_index, MAX_SIZE);
585 bool pop_implementation()
587 if (current_size == 0)
593 p_buffer[read_index].~T();
595 read_index = get_next_index(read_index, MAX_SIZE);
605 reference front_implementation()
607 return p_buffer[read_index];
613 const_reference front_implementation()
const
615 return p_buffer[read_index];
619 iqueue_mpmc_mutex(
const iqueue_mpmc_mutex&);
620 iqueue_mpmc_mutex& operator =(
const iqueue_mpmc_mutex&);
635 template <
typename T,
size_t SIZE, const
size_t MEMORY_MODEL = etl::memory_model::MEMORY_MODEL_LARGE>
636 class queue_mpmc_mutex :
public etl::iqueue_mpmc_mutex<T, MEMORY_MODEL>
640 typedef etl::iqueue_mpmc_mutex<T, MEMORY_MODEL> base_t;
644 typedef typename base_t::size_type size_type;
648 static ETL_CONSTANT size_type MAX_SIZE = size_type(SIZE);
654 : base_t(reinterpret_cast<T*>(&buffer[0]), MAX_SIZE)
668 queue_mpmc_mutex(
const queue_mpmc_mutex&) ETL_DELETE;
669 queue_mpmc_mutex& operator = (
const queue_mpmc_mutex&) ETL_DELETE;
672 queue_mpmc_mutex(queue_mpmc_mutex&&) =
delete;
673 queue_mpmc_mutex& operator = (queue_mpmc_mutex&&) =
delete;
680 template <
typename T,
size_t SIZE, const
size_t MEMORY_MODEL>
681 ETL_CONSTANT
typename queue_mpmc_mutex<T, SIZE, MEMORY_MODEL>::size_type queue_mpmc_mutex<T, SIZE, MEMORY_MODEL>::MAX_SIZE;
This mutex class is implemented using CMSIS's RTOS2 mutexes.
Definition: mutex_cmsis_os2.h:43
Definition: alignment.h:221
Definition: integral_limits.h:468
add_rvalue_reference
Definition: type_traits_generator.h:1327
bitset_ext
Definition: absolute.h:38
size_t max_size() const
Returns the maximum number of items in the variant_pool.
Definition: variant_pool_generator.h:281
Definition: memory_model.h:50