tRingBuffer.h

Go to the documentation of this file.

// this is for emacs file handling -*- mode: c++; indent-tabs-mode: nil -*-

// -- BEGIN LICENSE BLOCK ----------------------------------------------
// This file is part of FZIs ic_workspace.
//
// This program is free software licensed under the LGPL
// (GNU LESSER GENERAL PUBLIC LICENSE Version 3).
// You can find a copy of this license in LICENSE folder in the top
// directory of the source code.
//
// © Copyright 2016 FZI Forschungszentrum Informatik, Karlsruhe, Germany
//
// -- END LICENSE BLOCK ------------------------------------------------

//----------------------------------------------------------------------
//----------------------------------------------------------------------
#ifndef ICL_CORE_T_RING_BUFFER_H_INCLUDED
#define ICL_CORE_T_RING_BUFFER_H_INCLUDED

#include <stdexcept>
#include <vector>

#include "icl_core/BaseTypes.h"
#include "icl_core/Deprecate.h"

namespace icl_core {

template <typename T>
class ICL_CORE_VC_DEPRECATE tRingBuffer
{
public:
  typedef T value_type;
  typedef size_t size_type;
  static const size_type cDEFAULT_CAPACITY = 32;

  tRingBuffer(size_type capacity = cDEFAULT_CAPACITY)
    : m_buffer(capacity+1), m_write(0), m_read(0)
  { }

  tRingBuffer(const tRingBuffer<T>& other)
    : m_buffer(other.m_buffer), m_write(other.m_write), m_read(other.m_read)
  { }

  tRingBuffer& operator = (const tRingBuffer<T>& other)
  {
    m_buffer = other.m_buffer;
    m_write = other.m_write;
    m_read = other.m_read;
    return *this;
  }

  void Clear() { m_write = m_read = 0; }


  void Write(const T& val, bool overwrite=false)
  {
    size_type new_write_pos = m_write+1;
    if (new_write_pos >= m_buffer.size())
    {
      new_write_pos = 0;
    }
    if (new_write_pos == m_read)
    {
      if (overwrite)
      {
        Skip();
      }
      else
      {
        throw std::out_of_range("tRingBuffer::Write: capacity exceeded");
      }
    }
    m_buffer[m_write] = val;
    m_write = new_write_pos;
  }


  const T& At(size_type pos) const
  {
    if (pos < Size())
    {
      pos += m_read;
      if (pos >= m_buffer.size())
      {
        pos -= m_buffer.size();
      }
      return m_buffer[pos];
    }
    else
    {
      throw std::out_of_range("tRingBuffer::Peek: out of range");
    }
  }


  T& At(size_type pos)
  {
    if (pos < Size())
    {
      pos += m_read;
      if (pos >= m_buffer.size())
      {
        pos -= m_buffer.size();
      }
      return m_buffer[pos];
    }
    else
    {
      throw std::out_of_range("tRingBuffer::Peek: out of range");
    }
  }

  void Skip()
  {
    if (m_write == m_read)
    {
      throw std::out_of_range("tRingBuffer::Skip: buffer empty");
    }
    m_read++;
    if (m_read >= m_buffer.size())
    {
      m_read = 0;
    }
  }


  T Read()
  {
    if (m_write == m_read)
    {
      throw std::out_of_range("tRingBuffer::Read: buffer empty");
    }
    size_type read_pos = m_read;
    m_read++;
    if (m_read >= m_buffer.size())
    {
      m_read = 0;
    }
    return m_buffer[read_pos];
  }

  inline size_type Size() const
  {
    if (m_write >= m_read)
    {
      return m_write-m_read;
    }
    else
    {
      return m_write+m_buffer.size()-m_read;
    }
  }

  size_type Capacity() const { return m_buffer.size()-1; }


  void SetCapacity(size_type capacity)
  {
    size_type old_size = Size();
    size_type new_size = (capacity < old_size) ? capacity : old_size;
    std::vector<T> old_buffer(m_buffer);
    size_type old_read = m_read;

    // Adjust capacity.
    m_buffer.resize(capacity+1);
    // Skip elements that will not fit.
    old_read += old_size-new_size;
    if (old_read >= old_buffer.size())
    {
      old_read -= old_buffer.size();
    }
    // Copy the rest.
    for (size_type i=0; i<new_size; i++)
    {
      m_buffer[i] = old_buffer[old_read];
      old_read++;
      if (old_read >= old_buffer.size())
      {
        old_read = 0;
      }
    }
    // Update pointers.
    m_read = 0;
    m_write = new_size;
  }

  ~tRingBuffer()
  { }

private:
  std::vector<T> m_buffer;
  size_type m_write;
  size_type m_read;
} ICL_CORE_GCC_DEPRECATE;

}

#endif