IOBuffer.hh

Go to the documentation of this file.

#ifndef COSA_IOBUFFER_HH
#define COSA_IOBUFFER_HH

#include "Cosa/Types.h"
#include "Cosa/IOStream.hh"
#include "Cosa/Power.hh"

template <uint16_t SIZE>
class IOBuffer : public IOStream::Device {
  static_assert(SIZE && !(SIZE & (SIZE - 1)), "SIZE should be power of 2");
public:
  IOBuffer() :
    IOStream::Device(),
    m_head(0),
    m_tail(0)
  {}

  bool is_empty()
    __attribute__((always_inline))
  {
    return (m_head == m_tail);
  }

  bool is_full()
    __attribute__((always_inline))
  {
    return (((m_head + 1) & MASK) == m_tail);
  }

  virtual int available()
    __attribute__((always_inline))
  {
    return ((SIZE + m_head - m_tail) & MASK);
  }

  virtual int room()
    __attribute__((always_inline))
  {
    return ((SIZE - m_head + m_tail - 1) & MASK);
  }

  virtual int putchar(char c);

  virtual int peekchar();

  virtual int peekchar(char c);

  virtual int getchar();

  virtual int flush();

  virtual void empty()
    __attribute__((always_inline))
  {
    m_head = m_tail = 0;
  }

  operator const char*()
    __attribute__((always_inline))
  {
    return (&m_buffer[m_tail + 1]);
  }

private:
  static const uint16_t MASK = (SIZE - 1);
  volatile uint16_t m_head;
  volatile uint16_t m_tail;
  char m_buffer[SIZE];
};

template <uint16_t SIZE>
int
IOBuffer<SIZE>::putchar(char c)
{
  uint16_t next = (m_head + 1) & MASK;
  if (UNLIKELY(next == m_tail)) return (IOStream::EOF);
  m_buffer[next] = c;
  m_head = next;
  return (c & 0xff);
}

template <uint16_t SIZE>
int
IOBuffer<SIZE>::peekchar()
{
  if (UNLIKELY(m_head == m_tail)) return (IOStream::EOF);
  uint16_t next = (m_tail + 1) & MASK;
  return (m_buffer[next] & 0xff);
}

template <uint16_t SIZE>
int
IOBuffer<SIZE>::peekchar(char c)
{
  uint16_t tail = m_tail;
  int res = 0;
  while (tail != m_head) {
    res += 1;
    tail = (tail + 1) & MASK;
    if (UNLIKELY(m_buffer[tail] == c)) return (res);
  }
  return (IOStream::EOF);
}

template <uint16_t SIZE>
int
IOBuffer<SIZE>::getchar()
{
  if (UNLIKELY(m_head == m_tail)) return (IOStream::EOF);
  uint16_t next = (m_tail + 1) & MASK;
  m_tail = next;
  return (m_buffer[next] & 0xff);
}

template <uint16_t SIZE>
int
IOBuffer<SIZE>::flush()
{
  while (m_head != m_tail) yield();
  return (0);
}

#endif