fsb_circular_buffer.h

#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
 
namespace fsb
{
 
enum class CircularBufferStatus : uint8_t
{
    SUCCESS = 0,
    FULL,
    EMPTY,
    OVERWRITE
};
 
template <typename BufferType, size_t BufferSize> class CircularBuffer
{
public:
    CircularBuffer() = default;
 
    CircularBufferStatus push(BufferType push_value);
 
    CircularBufferStatus force_push(BufferType push_value);
 
    CircularBufferStatus pop(BufferType& popped_value);
 
    CircularBufferStatus
    pop_all(std::array<BufferType, BufferSize>& popped_values, size_t& num_popped);
 
    void reset();
 
    [[nodiscard]] size_t get_filled() const
    {
        size_t filled_size = 0;
        if (m_full)
        {
            filled_size = BufferSize;
        }
        else
        {
            filled_size = (m_tail > m_head ? (BufferSize - m_tail) + m_head : m_head - m_tail);
        }
        return filled_size;
    }
 
    [[nodiscard]] size_t get_remaining() const
    {
        size_t remaining_size = 0;
        if (m_full)
        {
            remaining_size = 0;
        }
        else
        {
            remaining_size = (m_tail > m_head ? m_tail - m_head : BufferSize - (m_head - m_tail));
        }
        return remaining_size;
    }
 
    static size_t get_size()
    {
        return BufferSize;
    }
 
private:
    std::array<BufferType, BufferSize> m_buffer = {};
    size_t m_tail = 0;
    size_t m_head = 0;
    bool m_full = false;
};
 
// ===============================
// CircularBuffer Implementation
// ===============================
 
template <typename BufferType, size_t BufferSize>
inline CircularBufferStatus CircularBuffer<BufferType, BufferSize>::push(BufferType push_value)
{
    auto status = CircularBufferStatus::SUCCESS;
    if (get_remaining() == 0)
    {
        status = CircularBufferStatus::FULL;
    }
    else
    {
        // push to head of queue
        m_buffer[m_head] = push_value;
        m_head = (m_head + 1) % BufferSize;
        m_full = (m_head == m_tail);
    }
    return status;
}
 
template <typename BufferType, size_t BufferSize>
inline CircularBufferStatus
CircularBuffer<BufferType, BufferSize>::force_push(BufferType push_value)
{
    auto status = CircularBufferStatus::SUCCESS;
    if (get_remaining() == 0)
    {
        m_buffer[m_head] = push_value;
        m_head = (m_head + 1) % BufferSize;
        m_tail = m_head;
        status = CircularBufferStatus::OVERWRITE;
    }
    else
    {
        // push to head of queue
        m_buffer[m_head] = push_value;
        m_head = (m_head + 1) % BufferSize;
        m_full = (m_head == m_tail);
    }
    return status;
}
 
template <typename BufferType, size_t BufferSize>
inline CircularBufferStatus CircularBuffer<BufferType, BufferSize>::pop(BufferType& popped_value)
{
    auto status = CircularBufferStatus::SUCCESS;
    if (get_filled() == 0)
    {
        status = CircularBufferStatus::EMPTY;
    }
    else
    {
        // consume at tail of queue
        popped_value = m_buffer[m_tail];
        // advance
        m_tail = (m_tail + 1) % BufferSize;
        m_full = false;
    }
    return status;
}
 
template <typename BufferType, size_t BufferSize>
CircularBufferStatus CircularBuffer<BufferType, BufferSize>::pop_all(
    std::array<BufferType, BufferSize>& popped_values, size_t& num_popped)
{
    num_popped = 0;
    while (get_filled() > 0)
    {
        // consume at tail of queue
        popped_values[num_popped] = m_buffer[m_tail];
        num_popped++;
        // advance
        m_tail = (m_tail + 1) % BufferSize;
        m_full = false;
    }
    return CircularBufferStatus::SUCCESS;
}
 
template <typename BufferType, size_t BufferSize>
inline void CircularBuffer<BufferType, BufferSize>::reset()
{
    m_head = 0;
    m_tail = 0;
    m_full = false;
}
 
} // namespace fsb