PrintCompat.h

Go to the documentation of this file.

//
// Created by David Cherry on 24/07/2020.
//
 
#ifndef IOA_PRINT_COMPAT_H
#define IOA_PRINT_COMPAT_H
 
#include <cstdlib>
#include <TextUtilities.h>
#include <inttypes.h>
 
#ifdef IOA_USE_ARDUINO
# error "Print compatibility has been included on Arduino, this will cause problems, please report."
#endif
 
// These are definitions of the mode in which the integer print can work, either decimal, hex or binary.
#define DEC 10
#define HEX 16
#define BIN 2
 
class Print {
public:
    virtual size_t write(uint8_t ch) = 0;
 
    virtual size_t write(const char* sz) {
        int written = 0;
        while(*sz) {
            write(*sz);
            sz++;
            written++;
        }
        return written;
    }
 
    void print(char ch) {
        write(ch);
    }
 
    void println(char ch) {
        write(ch);
        write('\n');
    }
 
    void print(const char* sz) { write(sz); }
 
    void println(const char* sz) {
        write(sz);
        write('\n');
    }
 
    void print(int val, int radix = DEC) {
        char sz[33];
        itoa(val, sz, radix);
        write(sz);
    }
 
    void println(int val, int radix = DEC) {
        print(val, radix);
        write('\n');
    }
 
    void print(unsigned int val, int radix = DEC) {
        char sz[33];
        itoa(int(val), sz, radix);
        write(sz);
    }
 
    void println(unsigned int val, int radix = DEC) {
        print(int(val), radix);
        write('\n');
    }
 
    void print(long val, int radix = DEC) {
        print((int)val, radix);
    }
 
    void println(long val, int radix = DEC) {
        print((int)val, radix);
        write('\n');
    }
 
    void print(unsigned long val, int radix = DEC) {
        char sz[33];
        itoa(int(val), sz, radix);
        write(sz);
    }
 
    void println(unsigned long val, int radix = DEC) {
        print(val, radix);
        write('\n');
    }
 
    void print(double dbl, int dp = 3) {
        char sz[32];
        sz[0]=0;
        fastftoa(sz, (float)dbl, dp, sizeof sz);
        write(sz);
    }
 
    void println(double dbl, int dp = 3) {
        print(dbl, dp);
        write('\n');
    }
 
    void print(bool b) {
        write(b ? "true" : "false");
    }
 
    void println(bool b) {
        write(b ? "true\n" : "false\n");
    }
 
    void println() {
        write('\n');
    }
 
    //
    // the following are to handle cases where write is called with basically an invalid type. I'd personally
    // of liked not to port this, but too much code relies on it being there.
    //
 
    inline size_t write(short t) { return write((uint8_t)t); }
    inline size_t write(unsigned short t) { return write((uint8_t)t); }
    inline size_t write(int t) { return write((uint8_t)t); }
    inline size_t write(unsigned int t) { return write((uint8_t)t); }
    inline size_t write(long t) { return write((uint8_t)t); }
    inline size_t write(unsigned long t) { return write((uint8_t)t); }
    // Enable write(char) to fall through to write(uint8_t)
    inline size_t write(char c) { return write((uint8_t) c); }
    inline size_t write(int8_t c) { return write((uint8_t) c); }
};
 
//forward definition of yield() function
void yield();
 
#endif //IOA_PRINT_COMPAT_H