mn_ringbuffer.hpp

Go to the documentation of this file.

 
#ifndef MINLIB_ESP32_RINGBUFFER_
#define MINLIB_ESP32_RINGBUFFER_
 
#include "mn_config.hpp"
 
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
 
#include "mn_autolock.hpp"
#include "mn_allocator.hpp"
 
 
namespace mn {
 
    namespace container {
 
        template<typename T, typename E = typename T::value_type>
        class basic_ring_buffer_iterator
        {
        public:
            using value_type = T;
            using size_type = size_t;
            using difference_type = ptrdiff_t;
            using pointer = T*;
            using const_pointer = const T*;
            using reference = T&;
            using const_reference = const T&;
            using self_type = basic_ring_buffer_iterator<T>;
 
            using ringbuffer_iterator = typename T::iterator;
            using const_ringbuffer_iterator = typename T::const_iterator;
 
            basic_ring_buffer_iterator(pointer b, size_t start_pos)
                : m_buf(b), m_pos(start_pos) { }
            basic_ring_buffer_iterator(const basic_ring_buffer_iterator& it)
                : m_buf(it.m_buf), m_pos(it.m_pos) { }
 
            basic_ring_buffer_iterator& operator = (const basic_ring_buffer_iterator& it) {
                m_buf = it.m_buf; m_pos = it.m_pos; return *this;
            }
 
            E &operator*() {
                return (*m_buf)[m_pos];
            }
            E *operator->() {
                return &(operator*());
            }
            self_type &operator++() {
                ++m_pos;
                return *this;
            }
            self_type &operator--() {
                --m_pos;
                return *this;
            }
            self_type operator ++ (int) {
                self_type tmp(*this);
                ++(*this);
                return tmp;
            }
            self_type operator -- (int) {
                self_type tmp(*this);
                --(*this);
                return tmp;
            }
            self_type operator + (difference_type n) {
                self_type tmp(*this);
                tmp.m_pos += n;
                return tmp;
            }
            self_type operator - (difference_type n) {
                self_type tmp(*this);
                tmp.m_pos -= n;
                return tmp;
            }
            self_type &operator += (difference_type n) {
                m_pos += n;
                return *this;
            }
            self_type &operator -= (difference_type n) {
                m_pos -= n;
                return *this;
            }
            bool operator == (const self_type &other) const {
                return (this->m_pos == other.m_pos);
            }
            bool operator != (const self_type &other) const {
                return (this->m_pos != other.m_pos);
            }
            value_type& operator [] (difference_type n) const {
                return *(*this + n);
            }
            bool operator < (const self_type& it) const {
                    return m_pos < it.m_pos;
            }
            bool operator > (const self_type& it) const {
                return   it < *this;
            }
            bool operator <= (const self_type& it) const {
                return !(it < *this);
            }
            bool operator >= (const self_type& it) const {
                return !(*this < it);
            }
        private:
            value_type *m_buf;
            size_t     m_pos;
        };
 
        template <class T, size_t TCAPACITY = 100, typename TLOCK = LockType_t >
        class basic_ring_buffer {
        public:
            using value_type = T;
            using pointer = T*;
            using const_pointer = const T*;
            using reference = T&;
            using const_reference = const T&;
            using size_type = size_t;
            using difference_type = ptrdiff_t;
            using lock_type = TLOCK;
            using lock_guard = basic_autolock<TLOCK>;
            using self_type = basic_ring_buffer<T, TCAPACITY, TLOCK>;
 
            using iterator = basic_ring_buffer_iterator<self_type, value_type> ;
            using const_iterator = basic_ring_buffer_iterator<self_type, const value_type>;
 
            basic_ring_buffer() :  m_Head(0), m_Tail(0), m_ContentsSize(0) { }
 
            void clear()  {
                lock_guard lock(m_lockObject);
                m_Head = m_Tail = m_ContentsSize = 0;
                memset(m_Array, 0, TCAPACITY);
            }
            void reset() {
                lock_guard lock(m_lockObject);
                m_Head = m_Tail = 0;
            }
 
            void push_back(const value_type &value) {
                lock_guard lock(m_lockObject);
 
                inc_tail();
                if (m_ContentsSize == TCAPACITY)
                    inc_head();
 
                m_Array[m_Tail] = value;
            }
            reference pop_front() {
                lock_guard lock(m_lockObject);
 
                inc_head();
                return m_Array[m_Head];
            }
            const_reference pop_front() const {
                lock_guard lock(m_lockObject);
 
                inc_head();
                return m_Array[m_Head];
            }
 
            iterator begin() {
                lock_guard lock(m_lockObject);
                return iterator(this, TCAPACITY == 0 ? 0 : m_Array[m_Head] );
            }
            iterator end() {
                lock_guard lock(m_lockObject);
                return iterator(this, TCAPACITY);
            }
            const_iterator cbegin() {
                lock_guard lock(m_lockObject);
                return const_iterator(this, 0);
            }
            const_iterator cend() {
                lock_guard lock(m_lockObject);
                return const_iterator(this, TCAPACITY);
            }
            reference       rfront() {
                lock_guard lock(m_lockObject);
                return m_Array[m_Head];
            }
            const_reference crfront() const {
                lock_guard lock(m_lockObject);
                return m_Array[m_Head];
            }
            const_reference crback() const  {
                lock_guard lock(m_lockObject);
                return m_Array[m_Tail];
            }
            reference       rback()  {
                lock_guard lock(m_lockObject);
                return m_Array[m_Tail];
            }
 
            size_type size() const {
                lock_guard lock(m_lockObject);
                return TCAPACITY;
            }
            size_type capacity() const {
                lock_guard lock(m_lockObject);
                return m_ContentsSize;
            }
            bool empty() const {
                lock_guard lock(m_lockObject);
                return TCAPACITY == 0;
            }
            bool full() const {
                lock_guard lock(m_lockObject);
                return TCAPACITY == m_ContentsSize;
            }
            size_type max() const {
                lock_guard lock(m_lockObject);
                return size_type(-1) / sizeof(value_type);
            }
 
            size_t get_head() {
                lock_guard lock(m_lockObject);
                return m_Head;
            }
            size_t get_tail() {
                lock_guard lock(m_lockObject);
                return m_Tail;
            }
 
 
        private:
            void inc_tail() {
                ++m_Tail;
                ++m_ContentsSize;
 
                if (m_Tail == TCAPACITY)  m_Tail = 0;
            }
            void inc_head() {
                ++m_Head;
                --m_ContentsSize;
 
                if (m_Head == TCAPACITY) m_Head = 0;
            }
        private:
            T           m_Array[TCAPACITY];
            size_t      m_Head;
            size_t      m_Tail;
            size_t      m_ContentsSize;
            lock_type   m_lockObject;
        };
 
        template <class T, size_t TCAPACITY = 100, typename TLOCK = LockType_t >
        using ringbuffer_t = basic_ring_buffer<T, TCAPACITY, TLOCK>;
 
#ifdef __EXPERT
        template<class TRingBuffer, class TARRAY >
        inline int write(TRingBuffer& rng, TARRAY& _array) {
            using size_type = typename TRingBuffer::size_type;
            size_type t = 0;
 
            for(; t < _array.size(); t++) {
                rng.push_back(_array[t]);
            }
 
            return t;
        }
 
        template<class TRingBuffer,
                 typename value_type = typename TRingBuffer::value_type,
                 typename size_type = typename TRingBuffer::size_type>
        inline int write(TRingBuffer& rng, const value_type* tarray, const size_type size ) {
            size_type t = 0;
 
            for(; t < size; t++) {
                rng.push_back(_array[t]);
            }
            return t;
        }
#endif
    }
 
}
 
#endif // MINLIB_ESP32_RINGBUFFER_