BufferedPrint.h

Go to the documentation of this file.

 
#ifndef BufferedPrint_h
#define BufferedPrint_h
#include "common/FmtNumber.h"
template <typename WriteClass, uint8_t BUF_DIM> class BufferedPrint
{
  public:
    BufferedPrint() : m_wr(nullptr), m_in(0)
    {
    }
    explicit BufferedPrint(WriteClass *wr) : m_wr(wr), m_in(0)
    {
    }
    void begin(WriteClass *wr)
    {
        m_wr = wr;
        m_in = 0;
    }
    void flush()
    {
        sync();
    }
    size_t printField(char c, char term)
    {
        char buf[3];
        char *str = buf + sizeof(buf);
        if (term)
        {
            *--str = term;
            if (term == '\n')
            {
                *--str = '\r';
            }
        }
        *--str = c;
        return write(str, buf + sizeof(buf) - str);
    }
    size_t printField(const __FlashStringHelper *fsh, char term)
    {
#ifdef __AVR__
        size_t rtn = 0;
        PGM_P p = reinterpret_cast<PGM_P>(fsh);
        char c;
        while ((c = pgm_read_byte(p++)))
        {
            if (!write(&c, 1))
            {
                return 0;
            }
            rtn++;
        }
        if (term)
        {
            char buf[2];
            char *str = buf + sizeof(buf);
            *--str = term;
            if (term == '\n')
            {
                *--str = '\r';
            }
            rtn += write(str, buf + sizeof(buf) - str);
        }
        return rtn;
#else  // __AVR__
        return printField(reinterpret_cast<const char *>(fsh), term);
#endif // __AVR__
    }
    size_t printField(const char *str, char term)
    {
        size_t rtn = write(str, strlen(str));
        if (term)
        {
            char buf[2];
            char *ptr = buf + sizeof(buf);
            *--ptr = term;
            if (term == '\n')
            {
                *--ptr = '\r';
            }
            rtn += write(ptr, buf + sizeof(buf) - ptr);
        }
        return rtn;
    }
    size_t printField(double d, char term, uint8_t prec = 2)
    {
        char buf[24];
        char *str = buf + sizeof(buf);
        if (term)
        {
            *--str = term;
            if (term == '\n')
            {
                *--str = '\r';
            }
        }
        str = fmtDouble(str, d, prec, false);
        return write(str, buf + sizeof(buf) - str);
    }
    size_t printField(float f, char term, uint8_t prec = 2)
    {
        return printField(static_cast<double>(f), term, prec);
    }
    template <typename Type> size_t printField(Type n, char term)
    {
        const uint8_t DIM = sizeof(Type) <= 2 ? 8 : 13;
        char buf[DIM];
        char *str = buf + sizeof(buf);
 
        if (term)
        {
            *--str = term;
            if (term == '\n')
            {
                *--str = '\r';
            }
        }
        Type p = n < 0 ? -n : n;
        if (sizeof(Type) <= 2)
        {
            str = fmtBase10(str, (uint16_t)p);
        }
        else
        {
            str = fmtBase10(str, (uint32_t)p);
        }
        if (n < 0)
        {
            *--str = '-';
        }
        return write(str, buf + sizeof(buf) - str);
    }
    size_t println()
    {
        char buf[2];
        buf[0] = '\r';
        buf[1] = '\n';
        return write(buf, 2);
    }
    size_t print(double d, uint8_t prec = 2)
    {
        return printField(d, 0, prec);
    }
    size_t println(double d, uint8_t prec = 2)
    {
        return printField(d, '\n', prec);
    }
    size_t print(float f, uint8_t prec = 2)
    {
        return printField(static_cast<double>(f), 0, prec);
    }
    size_t println(float f, uint8_t prec)
    {
        return printField(static_cast<double>(f), '\n', prec);
    }
    template <typename Type> size_t print(Type v)
    {
        return printField(v, 0);
    }
    template <typename Type> size_t println(Type v)
    {
        return printField(v, '\n');
    }
 
    bool sync()
    {
        if (!m_wr || m_wr->write(m_buf, m_in) != m_in)
        {
            return false;
        }
        m_in = 0;
        return true;
    }
    size_t write(const void *src, size_t n)
    {
        if ((m_in + n) > sizeof(m_buf))
        {
            if (!sync())
            {
                return 0;
            }
            if (n >= sizeof(m_buf))
            {
                return n == m_wr->write((const uint8_t *)src, n) ? n : 0;
            }
        }
        memcpy(m_buf + m_in, src, n);
        m_in += n;
        return n;
    }
 
  private:
    WriteClass *m_wr;
    uint8_t m_in;
    // Insure room for double.
    uint8_t m_buf[BUF_DIM < 24 ? 24 : BUF_DIM]; // NOLINT
};
#endif // BufferedPrint_h