CircularBuffer.h

Go to the documentation of this file.

/*
  CircularBuffer - An Arduino circular buffering library for arbitrary types.
 
  Created by Ivo Pullens, Emmission, 2014-2016 -- www.emmission.nl
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
 
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/
 
#ifndef CircularBuffer_h
#define CircularBuffer_h
 
template <class T> class CircularBuffer
{
public:
    CircularBuffer(T* buffer, const uint8_t size )
        : m_size(size), m_buff(buffer)
    {
        clear();
    }
 
    void clear(void)
    {
        MY_CRITICAL_SECTION {
            m_front = 0;
            m_fill  = 0;
        }
    }
 
    inline bool empty(void) const
    {
        bool empty;
        MY_CRITICAL_SECTION {
            empty = !m_fill;
        }
        return empty;
    }
 
    inline bool full(void) const
    {
        bool full;
        MY_CRITICAL_SECTION {
            full = m_fill == m_size;
        }
        return full;
    }
 
    inline uint8_t available(void) const
    {
        uint8_t ret_value;
        MY_CRITICAL_SECTION {
            ret_value = m_fill;
        }
        return ret_value;
    }
 
    T* getFront(void) const
    {
        MY_CRITICAL_SECTION {
            if (!full())
            {
                return get(m_front);
            }
        }
        return static_cast<T*>(NULL);
    }
 
    bool pushFront(T* record)
    {
        MY_CRITICAL_SECTION {
            if (!full())
            {
                T* f = get(m_front);
                if (f != record) {
                    *f = *record;
                }
                m_front = (m_front+1) % m_size;
                m_fill++;
                return true;
            }
        }
        return false;
    }
 
    T* getBack(void) const
    {
        MY_CRITICAL_SECTION {
            if (!empty())
            {
                return get(back());
            }
        }
        return static_cast<T*>(NULL);
    }
 
    bool popBack(void)
    {
        MY_CRITICAL_SECTION {
            if (!empty())
            {
                m_fill--;
                return true;
            }
        }
        return false;
    }
 
protected:
    inline T * get(const uint8_t idx) const
    {
        return &(m_buff[idx]);
    }
 
    inline uint8_t back(void) const
    {
        return (m_front - m_fill + m_size) % m_size;
    }
 
    const uint8_t      m_size;     
    T* const           m_buff;     
    volatile uint8_t   m_front;    
    volatile uint8_t   m_fill;     
};
 
#endif // CircularBuffer_h