You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
200 lines
5.6 KiB
200 lines
5.6 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2026 Jon Beniston, M7RCE <jon@beniston.com> // |
|
// // |
|
// This program is free software; you can redistribute it and/or modify // |
|
// it under the terms of the GNU General Public License as published by // |
|
// the Free Software Foundation as version 3 of the License, or // |
|
// (at your option) any later version. // |
|
// // |
|
// This program 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 General Public License V3 for more details. // |
|
// // |
|
// You should have received a copy of the GNU General Public License // |
|
// along with this program. If not, see <http://www.gnu.org/licenses/>. // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#ifndef INCLUDE_CIRCULARBUFFER_H_ |
|
#define INCLUDE_CIRCULARBUFFER_H_ |
|
|
|
#include <iterator> |
|
#include <cstddef> |
|
#include <vector> |
|
#include <algorithm> |
|
#include <iostream> |
|
|
|
// Iterates from oldest item to newest |
|
template<typename T> |
|
class CircularBufferIterator { |
|
|
|
using iterator_category = std::forward_iterator_tag; |
|
using value_type = T; |
|
using pointer = T *; |
|
using const_pointer = const T *; |
|
using reference = T &; |
|
using const_reference = const T &; |
|
using size_type = std::size_t; |
|
using difference_type = std::ptrdiff_t; |
|
|
|
public: |
|
CircularBufferIterator(std::vector<value_type> *b, size_t tail, size_t p) : |
|
m_buf(b), |
|
m_tail(tail), |
|
m_pos(p) |
|
{ |
|
} |
|
|
|
value_type &operator*() { return (*m_buf)[(m_tail + m_pos) % m_buf->size()]; } |
|
value_type *operator->() { return &(operator*()); } |
|
|
|
CircularBufferIterator<value_type> &operator++() |
|
{ |
|
m_pos++; |
|
return *this; |
|
} |
|
|
|
friend bool operator!= (const CircularBufferIterator<value_type>& a, const CircularBufferIterator<value_type>& b) { return a.m_buf != b.m_buf || a.m_tail != b.m_tail || a.m_pos != b.m_pos; }; |
|
|
|
private: |
|
std::vector<value_type> *m_buf; |
|
size_type m_tail; |
|
size_type m_pos; |
|
}; |
|
|
|
// Circular buffer with fixed capacity, that overwrites oldest item when full. |
|
// Items are stored in a contiguous block of memory, so can be accessed by index or iterated over. |
|
// Index of 0 is the oldest item, index of size()-1 is the newest item. |
|
template <class T> |
|
class CircularBuffer |
|
{ |
|
using value_type = T; |
|
using pointer = T *; |
|
using const_pointer = const T *; |
|
using reference = T &; |
|
using const_reference = const T &; |
|
using size_type = std::size_t; |
|
using difference_type = std::ptrdiff_t; |
|
|
|
std::vector<value_type> m_buffer; |
|
size_type m_head; |
|
size_type m_tail; |
|
size_type m_count; |
|
|
|
public: |
|
|
|
CircularBuffer(size_type size) : |
|
m_buffer(size), |
|
m_head(0), |
|
m_tail(0), |
|
m_count(0) |
|
{ |
|
} |
|
|
|
bool isFull() const |
|
{ |
|
return (m_count != 0) && (m_head == m_tail); |
|
} |
|
|
|
bool isEmpty() const |
|
{ |
|
return m_count == 0; |
|
} |
|
|
|
size_type size() const |
|
{ |
|
return m_count; |
|
} |
|
|
|
void clear() |
|
{ |
|
m_head = 0; |
|
m_tail = 0; |
|
m_count = 0; |
|
} |
|
|
|
void append(const_reference item) |
|
{ |
|
size_type next = (m_head + 1) % m_buffer.size(); |
|
if (isFull()) { |
|
m_tail = next; // Overwrite oldest item |
|
} else { |
|
m_count++; |
|
} |
|
m_buffer[m_head] = item; |
|
m_head = next; |
|
} |
|
|
|
void removeFirst() |
|
{ |
|
m_tail = (m_tail + 1) % m_buffer.size(); |
|
m_count--; |
|
} |
|
|
|
reference takeFirst() |
|
{ |
|
reference item = m_buffer[m_tail]; |
|
removeFirst(); |
|
return item; |
|
} |
|
|
|
// newSize of <= 1 not supported |
|
void resize(size_type newSize) |
|
{ |
|
// Reduce count to newSize, by removing oldest items first |
|
while (size() > newSize) { |
|
removeFirst(); |
|
} |
|
|
|
// Shuffle data to the beginning of the buffer, so we can free up or allocate space at the end |
|
if (m_head < m_tail) |
|
{ |
|
std::rotate(m_buffer.begin(), m_buffer.begin() + m_tail, m_buffer.end()); |
|
m_head = m_count; |
|
m_tail = 0; |
|
} |
|
else |
|
{ |
|
std::rotate(m_buffer.begin(), m_buffer.begin() + m_tail, m_buffer.begin() + m_head); |
|
m_head = m_count; |
|
m_tail = 0; |
|
} |
|
|
|
m_buffer.resize(newSize); |
|
|
|
if (m_head >= newSize) { |
|
m_head -= newSize; |
|
} |
|
} |
|
|
|
// Index of 0 is the oldest item, index of size()-1 is the newest item |
|
reference operator[] (size_type index) |
|
{ |
|
return m_buffer[(m_tail + index) % m_buffer.size()]; |
|
} |
|
|
|
const_reference operator[] (size_type index) const |
|
{ |
|
return m_buffer[(m_tail + index) % m_buffer.size()]; |
|
} |
|
|
|
const_reference at(size_type index) const |
|
{ |
|
return m_buffer.at((m_tail + index) % m_buffer.size()); |
|
} |
|
|
|
using iterator = CircularBufferIterator<T>; |
|
|
|
iterator begin() |
|
{ |
|
return iterator(&m_buffer, m_tail, 0); |
|
} |
|
|
|
iterator end() |
|
{ |
|
return iterator(&m_buffer, m_tail, m_count); |
|
} |
|
|
|
}; |
|
|
|
#endif /* INCLUDE_CIRCULARBUFFER_H_ */
|
|
|