ringbuffer.h

/*
 *      Copyright (C) 2022 Jean-Luc Barriere
 *
 *  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; either version 2, 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 for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
 *  MA 02110-1301 USA
 *  http://www.gnu.org/copyleft/gpl.html
 *
 */
 
#ifndef RINGBUFFER_H
#define RINGBUFFER_H
 
#include "local_config.h"
 
#include <cstring>
#include <cassert>
#include <vector>
#include <list>
 
namespace NSROOT
{
 
namespace OS
{
class Mutex;
}
 
class RingBufferPacket
{
public:
  RingBufferPacket(int _capacity);
  ~RingBufferPacket();
  unsigned id;
  int size;
  char * const data;
  const int capacity;
private:
  // prevent copy
  RingBufferPacket(const RingBufferPacket& other);
  RingBufferPacket& operator=(const RingBufferPacket& other);
};
 
class RingBuffer
{
public:
  RingBuffer(int capacity);
  virtual ~RingBuffer();

  int capacity() const;

  int bytesAvailable();

  unsigned bytesUnread() const;

  bool full() const;

  void clear();

  int write(const char * data, int len);

  RingBufferPacket * newPacket(int len);

  void writePacket(RingBufferPacket * packet);

  RingBufferPacket * read();

  void freePacket(RingBufferPacket * p);
 
private:
  // Prevent copy
  RingBuffer(const RingBuffer& other);
  RingBuffer& operator=(const RingBuffer& other);
 
private:
  mutable OS::Mutex * m_ringlock;
  mutable OS::Mutex * m_poollock;
  const int m_capacity;           
  unsigned m_count;               
  unsigned m_unread;              
 
  struct Chunk
  {
    Chunk() : packet(nullptr), next(nullptr) { }
    ~Chunk() { if (packet) delete packet; }
    RingBufferPacket * packet;
    Chunk * next;
  };
 
  std::vector<Chunk*> m_buffer;   
  Chunk * m_read;                 
  Chunk * m_write;                
 
  void init();
 
  std::list<RingBufferPacket*> m_pool;
  RingBufferPacket * needPacket(int size);
};
 
}
 
#endif /* RINGBUFFER_H */