IOStream.hh

Go to the documentation of this file.

#ifndef COSA_IOSTREAM_HH
#define COSA_IOSTREAM_HH

#include "Cosa/Types.h"

class IOStream {
public:
  static const int EOF = -1;

  static const char CR[] PROGMEM;
  static const char LF[] PROGMEM;
  static const char CRLF[] PROGMEM;

  enum Base {
    bcd = 0,
    bin = 2,
    oct = 8,
    dec = 10,
    hex = 16
  } __attribute__((packed));

  enum Mode {
    CR_MODE = 0,
    LF_MODE = 1,
    CRLF_MODE = 2
  } __attribute__((packed));

  class Device {
  public:
    Device() :
      m_blocking(false),
      m_eol(CR_MODE)
    {}

    void non_blocking()
    {
      m_blocking = false;
    }

    void blocking()
    {
      m_blocking = true;
    }

    bool is_blocking() const
    {
      return (m_blocking);
    }

    void eol(Mode mode)
    {
      m_eol = mode;
    }

    Mode eol() const
    {
      return (m_eol);
    }

    virtual int available();

    virtual int room();

    virtual int putchar(char c);

    virtual int puts(const char* s);

    virtual int puts(str_P s);

    virtual int write(const void* buf, size_t size);

    virtual int write_P(const void* buf, size_t size);

    virtual int write(const iovec_t* vec);

    virtual int peekchar();

    virtual int peekchar(char c);

    virtual int getchar();

    virtual char* gets(char *s, size_t count);

    virtual int read(void* buf, size_t size);

    virtual int read(iovec_t* vec);

    virtual int flush();

    virtual void empty();

  protected:
    bool m_blocking;

    Mode m_eol;
  };

  IOStream(Device* dev);
  IOStream();

  Device* device() const
  {
    return (m_dev);
  }

  Device* device(Device* dev)
  {
    Device* previous = m_dev;
    m_dev = dev;
    return (previous);
  }

  str_P eol() const
  {
    return (m_eols);
  }

  str_P EOL() const
  {
    return (m_eols);
  }

  void eol(str_P s)
  {
    m_eols = s;
  }

  int8_t width(int8_t value)
  {
    int8_t res = m_width;
    m_width = value;
    return (res);
  }

  uint8_t precision(uint8_t value)
  {
    uint8_t res = m_prec;
    m_prec = value;
    return (res);
  }

  void print(int value, Base base = dec);

  void print(long int value, Base base = dec);

  void print(unsigned int value, Base base = dec);

  void print(unsigned long int value, Base base = dec);

  void print(unsigned int value, uint8_t digits, Base base);

  void print(unsigned long int value, uint8_t digits, Base base);

  void print(double value, int8_t width, uint8_t prec);

  void print(uint32_t src, const void *ptr, size_t size,
             Base base = dec, uint8_t max = 16);

  void print(const void *ptr, size_t size,
             Base base = dec, uint8_t max = 16)
  {
    print((uint32_t) ptr, ptr, size, base, max);
  }

  void print(void *ptr)
  {
    print((unsigned int) ptr, hex);
  }

  void print(const void *ptr)
  {
    print((unsigned int) ptr, hex);
  }

  void print(char c)
    __attribute__((always_inline))
  {
    if (m_dev != NULL) m_dev->putchar(c);
  }

  void print(const char* s)
    __attribute__((always_inline))
  {
    if (m_dev != NULL) m_dev->puts(s);
  }

  void print(str_P s)
    __attribute__((always_inline))
  {
    if (m_dev != NULL) m_dev->puts(s);
  }

  void println()
    __attribute__((always_inline))
  {
    if (m_dev != NULL) m_dev->puts(m_eols);
  }

  void vprintf(str_P format, va_list args);

  void printf(str_P format, ...)
  {
    va_list args;
    va_start(args, format);
    vprintf(format, args);
    va_end(args);
  }

  void print(IOStream::Device* buffer);

  void flush()
    __attribute__((always_inline))
  {
    if (m_dev != NULL) m_dev->flush();
  }

  char* scan(char *s, size_t count);

  char* readline(char* buf, size_t size, bool echo = true);

  typedef IOStream& (*Manipulator)(IOStream&);

  IOStream& operator<<(Manipulator func)
  {
    return (func(*this));
  }

  IOStream& operator<<(int n)
  {
    print(n, m_base);
    m_base = dec;
    return (*this);
  }

  IOStream& operator<<(long int n)
  {
    print(n, m_base);
    m_base = dec;
    return (*this);
  }

  IOStream& operator<<(double n)
  {
    print(n, m_width, m_prec);
    m_base = dec;
    return (*this);
  }

  IOStream& operator<<(unsigned int n)
  {
    print(n, m_base);
    m_base = dec;
    return (*this);
  }

  IOStream& operator<<(unsigned long int n)
  {
    print(n, m_base);
    m_base = dec;
    return (*this);
  }

  IOStream& operator<<(void* ptr)
  {
    print(ptr);
    m_base = dec;
    return (*this);
  }

  IOStream& operator<<(const void* ptr)
  {
    print(ptr);
    m_base = dec;
    return (*this);
  }

  IOStream& operator<<(char c)
  {
    print(c);
    return (*this);
  }

  IOStream& operator<<(char* s)
  {
    print(s);
    return (*this);
  }

  IOStream& operator<<(const char* s)
  {
    print(s);
    return (*this);
  }

  IOStream& operator<<(str_P s)
  {
    print(s);
    return (*this);
  }

  IOStream& operator<<(IOStream& buffer)
  {
    print(&buffer);
    return (*this);
  }

  IOStream& operator<<(const iovec_t* vec)
  {
    if (m_dev != NULL) m_dev->write(vec);
    return (*this);
  }

#if !defined(COSA_IOSTREAM_STDLIB_DTOA)
  /* Faster version of standard number to string conversion */
  static char* ultoa(unsigned long __val, char *__s, int base);
  static char* ltoa(long __val, char *__s, int base);
  static char* utoa(unsigned int __val, char *__s, int base);
  static char* itoa(int __val, char *__s, int base);
#endif

  friend IOStream& bcd(IOStream& outs);
  friend IOStream& bin(IOStream& outs);
  friend IOStream& oct(IOStream& outs);
  friend IOStream& dec(IOStream& outs);
  friend IOStream& hex(IOStream& outs);
  friend IOStream& flush(IOStream& outs);

protected:
  Device* m_dev;             
  Base m_base;               
  int8_t m_width;            
  uint8_t m_prec;            
  str_P m_eols;              

  static const size_t BUF_MAX = sizeof(uint32_t) * CHARBITS + 1;

  void print_prefix(Base base);
};

inline IOStream&
bcd(IOStream& outs)
{
  outs.m_base = IOStream::bcd;
  return (outs);
}

inline IOStream&
bin(IOStream& outs)
{
  outs.m_base = IOStream::bin;
  return (outs);
}

inline IOStream&
oct(IOStream& outs)
{
  outs.m_base = IOStream::oct;
  return (outs);
}

inline IOStream&
dec(IOStream& outs)
{
  outs.m_base = IOStream::dec;
  return (outs);
}

inline IOStream&
hex(IOStream& outs)
{
  outs.m_base = IOStream::hex;
  return (outs);
}

inline IOStream&
tab(IOStream& outs)
{
  outs.print('\t');
  return (outs);
}

inline IOStream&
endl(IOStream& outs)
{
  outs.println();
  return (outs);
}

inline IOStream&
ends(IOStream& outs)
{
  outs.print('\0');
  return (outs);
}

inline IOStream&
clear(IOStream& outs)
{
  outs.print('\f');
  return (outs);
}

inline IOStream&
flush(IOStream& outs)
{
  if (outs.m_dev != NULL) outs.m_dev->flush();
  return (outs);
}
#endif