printer.h

Go to the documentation of this file.

 
#pragma once
 
#include <PropWare/PropWare.h>
#include <PropWare/hmi/output/printcapable.h>
#include <PropWare/utility/utility.h>
 
namespace PropWare {
 
#ifndef S_ISNAN
#define S_ISNAN(x) (x != x)
#endif  /* !defined(S_ISNAN) */
 
#ifndef S_ISINF
#define S_ISINF(x) (x != 0.0 && x + x == x)
#endif  /* !defined(S_ISINF) */
 
#ifndef isdigit
#define isdigit(x) ('0' <= x && x <= '9')
#endif
 
class Printer {
    public:
        static const uint16_t DEFAULT_WIDTH     = 0;
        static const uint16_t DEFAULT_PRECISION = 6;
        static const uint8_t  DEFAULT_RADIX     = 10;
        static const char     DEFAULT_FILL_CHAR = ' ';
 
        struct Format {
            uint16_t width;
            uint16_t precision;
            uint8_t  radix;
            char     fillChar;
 
            Format (const uint16_t width = DEFAULT_WIDTH, const char fillChar = DEFAULT_FILL_CHAR,
                    const uint8_t radix = DEFAULT_RADIX, const uint16_t precision = DEFAULT_PRECISION)
                    : width(width),
                      precision(precision),
                      radix(radix),
                      fillChar(fillChar) {
            }
        };
 
        static const Format DEFAULT_FORMAT;
 
    public:
        Printer (PrintCapable &printCapable, const bool cooked = true)
                : m_printCapable(&printCapable),
                  m_cooked(cooked) {
        }
 
        void set_cooked (const bool cooked) {
            this->m_cooked = cooked;
        }
 
        bool get_cooked () const {
            return this->m_cooked;
        }
 
        void put_char (const char c) const {
            if (this->m_cooked && '\n' == c)
                this->m_printCapable->put_char('\r');
            this->m_printCapable->put_char(c);
        }
 
        void puts (const char string[]) const {
            if (this->m_cooked)
                for (const char *s = string; *s; ++s)
                    this->put_char(*s);
            else
                this->m_printCapable->puts(string);
        }
 
        void put_int (int x, const uint8_t radix = 10, uint16_t width = 0,
                      const char fillChar = DEFAULT_FILL_CHAR) const {
            if (0 > x)
                this->put_char('-');
 
            this->put_uint((uint32_t) abs(x), radix, width, fillChar);
        }
 
        void put_uint (unsigned int x, const uint8_t radix = 10, uint16_t width = 0,
                       const char fillChar = DEFAULT_FILL_CHAR) const {
            char    buf[sizeof(x) * 8]; // Max size would be a single character for each bit - aka, bytes * 8
            uint_fast8_t i = 0;
 
            // Create a character array in reverse order, starting with the
            // tens digit and working toward the largest digit
            do {
                const unsigned int digit = x % radix;
                buf[i] = static_cast<char>(digit > 9 ? digit + 'A' - 10 : digit + '0');
                x /= radix;
                ++i;
            } while (x);
 
            if (width && width > i) {
                width -= i;
                while (width--)
                    this->put_char(fillChar);
            }
 
            // Reverse the character array
            for (unsigned int j = 0; j < i; ++j)
                this->put_char(buf[i - j - 1]);
        }
 
        void put_ll (long long x, const uint8_t radix = 10, uint16_t width = 0,
                     const char fillChar = DEFAULT_FILL_CHAR) const {
            if (0 > x)
                this->put_char('-');
 
            this->put_ull((unsigned long long) llabs(x), radix, width, fillChar);
        }
 
        void put_ull (unsigned long long x, const uint8_t radix = 10, uint16_t width = 0,
                      const char fillChar = DEFAULT_FILL_CHAR) const {
            char         buf[sizeof(x) * 8]; // Max size would be a single character for each bit - aka, bytes * 8
            uint_fast8_t i = 0;
 
            // Create a character array in reverse order, starting with the
            // tens digit and working toward the largest digit
            do {
                const uint_fast8_t digit = static_cast<uint_fast8_t>(x % radix);
                buf[i] = static_cast<char>(digit > 9 ? digit + 'A' - 10 : digit + '0');
                x /= radix;
                ++i;
            } while (x);
 
            if (width && width > i) {
                width -= i;
                while (width--)
                    this->put_char(fillChar);
            }
 
            // Reverse the character array
            for (unsigned int j = 0; j < i; ++j)
                this->put_char(buf[i - j - 1]);
        }
 
        void put_float (double f, uint16_t width = 0, uint16_t precision = 6,
                        const char fillChar = DEFAULT_FILL_CHAR) const {
            // Code taken straight from Parallax's floatToString! Thank you!!!
 
            char buffer[32];
            char *s = buffer;
            union convert {
                float v;
                int   w;
            }    fval;
 
            int m = 0;
            int k = 0;
 
            int j    = 0;
            int sign = 0;
            int g    = 0;
 
            int   reps = 0;
            float scale;
            int   ctr  = 0;
 
            int offset;
            int p;
            int q;
            int n;
 
            if (S_ISNAN(f)) {
                this->puts("nan");
            }
            if (S_ISINF(f)) {
                if (((int) f) & 0x80000000)
                    this->puts("-inf");
                else
                    this->puts("inf");
            }
 
            /* clamp the digits. */
            int clamp = 6; /* a buffer must be at least clamp + 4 digits */
            precision = (precision > clamp) ? clamp : precision;
 
            if (f < 0.0) {
                sign = 1;
                f    = -f;
            }
 
            if (sign) {
                s[j++] = '-';
            }
 
            /* Find reasonable starting value for scale.
            // Using 2^10x has similar values to 10^3x. */
            fval.v = f;
            g = fval.w;
 
            g >>= 23;
            g &= 0xFF;
            g -= 127;
 
            reps     = (g / 10);
            scale    = 1.0;
            for (ctr = 0; ctr <= reps; ctr++) {
                scale *= 1000.0;
            }
 
            /* If integer is zero, 0 */
            if (f < 1.0) {
                s[j++] = '0';
            }
            else {
                char c;
                for (; scale >= 1.0; scale /= 10.0) {
                    if (f >= scale) {
                        break;
                    }
                }
                for (; scale >= 1.0; scale /= 10.0) {
                    c = (char) (f / scale);
                    f -= ((float) c * scale);
                    c += 48;
                    s[j++] = c;
                }
            }
 
            /* If width > current size, move right, then pad with spaces */
            offset = width - j - precision - 1;
            if (precision == 0)
                offset++;
 
            p = j + offset;
            q = j;
            n = p;
 
            if (offset > 0) {
                for (; j >= 0;) {
                    s[n--] = s[j--];
                }
                for (; n >= 0;) {
                    s[n--] = fillChar;
                }
                j = p;
            }
            else
                j = q;
 
            /* Append with fractional */
            if (precision > 0)
                s[j++] = '.';
 
            k = j;
            k += precision;
            for (; j <= k;) {
                f *= 10.0;
                s[j++] = (char) f + '0';
                f -= ((int) f);
            }
 
            m = j - 1;
            j--;
            if (s[j] >= '5') {
                j--;
                for (; (j >= 0); j--)
                    if (!(s[j] < '0' || s[j] > '9')) {
                        if (s[j] < '9') {
                            s[j]++;
                            break;
                        } else
                            s[j] = '0';
                    }
            }
 
            s[m] = 0;
 
            this->puts(s);
        }
 
        template<typename T, typename... Targs>
        void printf (const char fmt[], const T first, const Targs... remaining) const {
            const char *s = fmt;
            char       c;
            Format     format;
 
            while (*s) {
                c = *s;
 
                if ('%' == c) {
                    c = *(++s);
                    if ('%' == c)
                        this->put_char(c);
                    else {
                        if (c == '0')
                            format.fillChar = '0';
                        else
                            format.fillChar = DEFAULT_FILL_CHAR;
 
                        format.width = 0;
                        while (c && isdigit(c)) {
                            format.width = (uint16_t) (10 * format.width + (c - '0'));
                            c = *(++s);
                        }
 
                        if (c == '.') {
                            format.precision = 0;
                            c = *(++s);
                            while (c && isdigit(c)) {
                                format.precision = (uint16_t) (10 * format.precision + (c - '0'));
                                c = *(++s);
                            }
                        }
 
                        ++s;
 
                        switch (c) {
                            case 'i':
                            case 'd':
                                this->print((int) first, format);
                                break;
                            case 'X':
                            case 'b':
                                format.radix = static_cast<uint8_t>('b' == c ? 2 : 16);
                                // No "break;" after 'X' - let it flow into 'u'
                            case 'u':
                                this->print((unsigned int) first, format);
                                break;
                            case 'f':
                            case 's':
                            case 'c':
                                this->print(first, format);
                                break;
                            default:
                                this->put_char(DEFAULT_FILL_CHAR);
                                break;
                        }
                        if (0 == sizeof...(remaining))
                            this->puts(s);
                        else {
                            this->printf(s, remaining...);
                        }
                        return;
                    }
                } else
                    this->put_char(*s);
 
                ++s;
            }
        }
 
        void printf (const char fmt[]) const {
            this->puts(fmt);
        }
 
        void print (const char c, const Format &format = DEFAULT_FORMAT) const {
            this->put_char(c);
        }
 
        void print (const char string[], const Format &format = DEFAULT_FORMAT) const {
            this->puts(string);
        }
 
        void println (const char string[]) const {
            this->puts(string);
            this->put_char('\n');
        }
 
        void println () const {
            this->put_char('\n');
        }
 
        void print (const bool b, const Format &format = DEFAULT_FORMAT) const {
            this->puts(Utility::to_string(b));
        }
 
        void print (const unsigned int x, const Format &format = DEFAULT_FORMAT) const {
            this->put_uint(x, format.radix, format.width, format.fillChar);
        }
 
        void print (const int x, const Format &format = DEFAULT_FORMAT) const {
            this->put_int(x, format.radix, format.width, format.fillChar);
        }
 
        void print (const unsigned long long x, const Format &format = DEFAULT_FORMAT) const {
            this->put_uint(x, format.radix, format.width, format.fillChar);
        }
 
        void print (const long long x, const Format &format = DEFAULT_FORMAT) const {
            this->put_int(x, format.radix, format.width, format.fillChar);
        }
 
        void print (const double f, const Format &format = DEFAULT_FORMAT) const {
            this->put_float(f, format.width, format.precision, format.fillChar);
        }
 
        template<typename T>
        const Printer &operator<< (const T arg) const {
            this->print(arg, this->m_format);
            return *this;
        }
 
        template<typename T>
        Printer &operator<< (const T arg) {
            this->print(arg, this->m_format);
            return *this;
        }
 
        Printer &operator<< (const Format arg) {
            this->m_format = arg;
            return *this;
        }
 
    protected:
        PrintCapable *m_printCapable;
        bool         m_cooked;
        Format       m_format;
};
 
}
 
#ifndef __PROPELLER_COG__
 
extern PropWare::Printer pwOut;
#endif