RingBuffer.hpp

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 2014 FZI Forschungszentrum Informatik, Karlsruhe, Germany
//
// -- END LICENSE BLOCK ------------------------------------------------

//----------------------------------------------------------------------
//----------------------------------------------------------------------
#ifndef ICL_CORE_RING_BUFFER_HPP_INCLUDED
#define ICL_CORE_RING_BUFFER_HPP_INCLUDED

namespace icl_core {

template <typename T>
typename RingBuffer<T>::array_range RingBuffer<T>::arrayOne()
{
  if (m_write >= m_read)
  {
    return array_range(&m_buffer[m_read], m_write-m_read);
  }
  else
  {
    return array_range(&m_buffer[m_read], m_buffer.size()-m_read);
  }
}

template <typename T>
typename RingBuffer<T>::const_array_range RingBuffer<T>::arrayOne() const
{
  if (m_write >= m_read)
  {
    return const_array_range(&m_buffer[m_read], m_write-m_read);
  }
  else
  {
    return const_array_range(&m_buffer[m_read], m_buffer.size()-m_read);
  }
}

template <typename T>
typename RingBuffer<T>::array_range RingBuffer<T>::arrayTwo()
{
  if (m_write >= m_read)
  {
    return array_range(&m_buffer[m_write], 0);
  }
  else
  {
    return array_range(&m_buffer[0], m_write);
  }
}

template <typename T>
typename RingBuffer<T>::const_array_range RingBuffer<T>::arrayTwo() const
{
  if (m_write >= m_read)
  {
    return const_array_range(&m_buffer[m_write], 0);
  }
  else
  {
    return const_array_range(&m_buffer[0], m_write);
  }
}

template <typename T>
typename RingBuffer<T>::array_range RingBuffer<T>::emptyArrayOne()
{
  if (m_write >= m_read)
  {
    if (m_read == 0)
    {
      return array_range(&m_buffer[m_write], m_buffer.size()-m_write-1);
    }
    else
    {
      return array_range(&m_buffer[m_write], m_buffer.size()-m_write);
    }
  }
  else
  {
    return array_range(&m_buffer[m_write], m_read-m_write-1);
  }
}

template <typename T>
typename RingBuffer<T>::const_array_range RingBuffer<T>::emptyArrayOne() const
{
  if (m_write >= m_read)
  {
    if (m_read == 0)
    {
      return const_array_range(&m_buffer[m_write], m_buffer.size()-m_write-1);
    }
    else
    {
      return const_array_range(&m_buffer[m_write], m_buffer.size()-m_write);
    }
  }
  else
  {
    return const_array_range(&m_buffer[m_write], m_read-m_write-1);
  }
}

template <typename T>
typename RingBuffer<T>::array_range RingBuffer<T>::emptyArrayTwo()
{
  if (m_write >= m_read)
  {
    return array_range(&m_buffer[0], (m_read>0?m_read:1) - 1);
  }
  else
  {
    return array_range(&m_buffer[m_read], 0);
  }
}

template <typename T>
typename RingBuffer<T>::const_array_range RingBuffer<T>::emptyArrayTwo() const
{
  if (m_write >= m_read)
  {
    return const_array_range(&m_buffer[0], (m_read>0?m_read:1) - 1);
  }
  else
  {
    return const_array_range(&m_buffer[m_read], 0);
  }
}

template <typename T>
void RingBuffer<T>::skip(size_type count)
{
  if (count >= size())
  {
    clear();
  }
  else
  {
    m_read = (m_read+count) % m_buffer.size();
  }
}

template <typename T>
void RingBuffer<T>::fakeWrite(size_t count)
{
  if (count > reserve())
  {
    count = reserve();
  }
  m_write = (m_write + count) % m_buffer.size();
}

#ifdef _IC_BUILDER_DEPRECATED_STYLE_

template <typename T>
void RingBuffer<T>::Clear()
{
  clear();
}


template <typename T>
void RingBuffer<T>::Write(const T& val, bool overwrite)
{
  write(val, overwrite);
}


template <typename T>
const T& RingBuffer<T>::At(size_type pos) const
{
  return at(pos);
}


template <typename T>
T& RingBuffer<T>::At(size_type pos)
{
  return at(pos);
}

template <typename T>
void RingBuffer<T>::Skip()
{
  skip();
}


template <typename T>
T RingBuffer<T>::Read()
{
  return read();
}

template <typename T>
typename RingBuffer<T>::size_type RingBuffer<T>::Size() const
{
  return size();
}

template <typename T>
typename RingBuffer<T>::size_type RingBuffer<T>::Capacity() const
{
  return capacity();
}


template <typename T>
void RingBuffer<T>::SetCapacity(size_type capacity)
{
  setCapacity(capacity);
}

#endif


}

#endif