A simple, generic buffer that accumulates items in a queue and processes them when a specified capacity is reached.

buffer.hpp

#pragma once

#include <cstddef>
#include <functional>
#include <queue>

//  A buffer class that accumulates items in a queue and processes them when a
//  specified capacity is reached.
template <typename T, std::size_t Capacity>
class Buffer {
 private:
  std::function<void(std::deque<T>&)> handler;

 public:
  std::deque<T> data;

  // Constructs a Buffer object with a given flush handler
  Buffer(const std::function<void(std::deque<T>&)> flush_handler)
      : handler{flush_handler} {}

  // Adds an element to the buffer. Flushes the buffer if it reaches its
  // capacity
  void push(const T& value) {
    data.push_back(value);

    if (data.size() >= Capacity) {
      flush();
    }
  }

  // Flushes the buffer by processing and emptying the queue. This method calls
  // the handler function to process the queue's elements
  void flush() {
    handler(data);
    data = std::deque<T>();
  }
};