TFifoClass.h

Go to the documentation of this file.

#pragma once
 
namespace sf
{
 
template<typename T>
class TFifoClass
{
  public:
    typedef int size_type;
 
    TFifoClass()
    {
      initialize();
    }
 
    explicit TFifoClass(size_type size)
    {
      initialize();
      set(size);
    }
 
    ~TFifoClass();
 
    bool push(const T& item);
 
    bool push();
 
    bool push(const T* item, size_type count);
 
    const T& peek() const;
 
    const T& latest() const;
 
    T pop();
 
    bool pop(T& item);
 
    [[nodiscard]] bool empty() const;
 
    [[nodiscard]] size_type size() const;
 
    [[nodiscard]] size_type sizeMax() const
    {
      return (_valid) ? (_bufSize - 1) : 0;
    }
 
    [[nodiscard]] size_type sizeRemain() const
    {
      return _valid ? (sizeMax() - size()) : 0;
    }
 
    [[nodiscard]] bool isValid() const
    {
      return _valid;
    }
 
    [[nodiscard]] bool isFull() const
    {
      return sizeRemain() ? 0 : 1;
    }
 
    void clear()
    {
      _head = _tail = 0;
    }
 
    bool set(size_type size);
 
    T& operator[](size_type pos);
 
    const T& operator[](size_type pos) const;
 
    [[nodiscard]] size_type getTail() const;
 
    [[nodiscard]] size_type getHead() const;
 
    const T* getBuffer(size_type pos = 0) const;
 
  private:
    void initialize();
 
    size_type _tail{0};
    size_type _head{0};
    T* _buffer{nullptr};
    size_type _valid{0};
    size_type _bufSize{0};
    T _zero;
};
 
template<typename T>
TFifoClass<T>::~TFifoClass()
{
  if (_valid)
  {
    delete[] _buffer;
  }
}
 
template<typename T>
void TFifoClass<T>::initialize()
{
  _valid = 0;
  _bufSize = 0;
  _head = 0;
  _tail = 0;
  _buffer = nullptr;
  memset(&_zero, 0, sizeof(T));
}
 
template<typename T>
bool TFifoClass<T>::set(TFifoClass<T>::size_type size)
{
  if (size < 1)
  {
    return false;
  }
  _bufSize = size + 1;
  _head = _tail = 0;
  if (_buffer)
  {
    delete[] _buffer;
  }
  _buffer = new T[_bufSize];
  memset(_buffer, 0, sizeof(T) * _bufSize);
  _valid = true;
  return true;
}
 
template<typename T>
bool TFifoClass<T>::push(const T& item)
{
  if ((((_tail + 1) % _bufSize)) == _head)
  {
    return false;
  }
  _buffer[_tail++] = item;
  _tail %= _bufSize;
  return true;
}
 
template<typename T>
bool TFifoClass<T>::push(const T* item, TFifoClass<T>::size_type count)
{
  if (sizeRemain() < count)
  {
    return true;
  }
  for (size_type i = 0; i < count; push(item[i++]))
  {
  }
  return false;
}
 
template<typename T>
bool TFifoClass<T>::push()
{
  return push(_zero);
}
 
template<typename T>
const T& TFifoClass<T>::peek() const
{
  if (_head == _tail)
  {
    return _zero;
  }
  return _buffer[_head];
}
 
template<typename T>
const T& TFifoClass<T>::latest() const
{
  if (_head == _tail)
  {
    return _zero;
  }
  return _buffer[(((_tail + _bufSize - 1) % _bufSize))];
}
 
template<typename T>
T TFifoClass<T>::pop()
{
  if (_tail == _head)
  {
    return _zero;
  }
  T tmp = _buffer[_head++];
  _head %= _bufSize;
  return tmp;
}
 
template<typename T>
bool TFifoClass<T>::pop(T& item)
{
  if (_tail == _head)
  {
    item = _zero;
    return false;
  }
  item = _buffer[_head++];
  _head %= _bufSize;
  return true;
}
 
template<typename T>
bool TFifoClass<T>::empty() const
{
  return size() == 0;
}
 
template<typename T>
typename TFifoClass<T>::size_type TFifoClass<T>::size() const
{
  return (_tail < _head) ? (_bufSize + (_tail - _head)) : (_tail - _head);
}
 
template<typename T>
T& TFifoClass<T>::operator[](TFifoClass<T>::size_type pos)
{
  return _buffer[(pos + _head) % _bufSize];
}
 
template<typename T>
const T& TFifoClass<T>::operator[](TFifoClass<T>::size_type pos) const
{
  return _buffer[(pos + _head) % _bufSize];
}
 
template<typename T>
inline const T* TFifoClass<T>::getBuffer(TFifoClass<T>::size_type pos) const
{
  return &_buffer[pos];
}
 
template<typename T>
inline typename TFifoClass<T>::size_type TFifoClass<T>::getTail() const
{
  return _tail;
}
 
template<typename T>
inline typename TFifoClass<T>::size_type TFifoClass<T>::getHead() const
{
  return _head;
}
 
}// namespace sf