Print.h

Go to the documentation of this file.

 
#ifndef Print_h
#define Print_h
 
#include <stdint.h>
#include <stddef.h>
#include <stdarg.h>
#include <cstring>
#include <type_traits>
#include <stdexcept>
 
#include "Printable.h"
#include "WString.h"
 
#define DEC 10
 
#define HEX 16
 
#define OCT 8
 
#define BIN 2
 
 
#define endl "\r\n"
 
#define __INTEGER_ONLY__(t, ret_type) template<typename t> typename std::enable_if_t<std::is_integral<t>::value, ret_type>
 
#define __INTEGER_ONLY__R(t) __INTEGER_ONLY__(t, t)
 
#define __SIGNED_INTEGER_ONLY__(t, ret_type) template<typename t> typename std::enable_if_t<std::is_integral<t>::value && std::is_signed<t>::value && !std::is_same<t, bool>::value, ret_type>
 
#define __UNSIGNED_INTEGER_ONLY__(t, ret_type) template<typename t> typename std::enable_if_t<std::is_integral<t>::value && (!std::is_signed<t>::value || std::is_same<t, bool>::value), ret_type>
 
#define __FLOATING_ONLY__(t, ret_type) template<typename t> typename std::enable_if_t<std::is_floating_point<t>::value, ret_type>
 
#define __FLOATING_ONLY__R(t) __FLOATING_ONLY__(t, t)
 
 
class Print {
    private:
        int write_error = 0;
 
        __INTEGER_ONLY__(T, size_t) printNumber(T n, uint8_t base){
            char buf[8 * sizeof(n) + 1]; // Assumes 8-bit chars plus zero byte.
            char* str = &buf[sizeof(buf) - 1];
 
            *str = '\0';
 
            // prevent crash if called with base == 1
            if (base < 2) {
                base = 10;
            }
 
            do {
                auto m = n;
                n /= base;
                char c = m - base * n;
 
                *--str = c < 10 ? c + '0' : c + 'A' - 10;
            } while (n);
 
            return write(str);
        }
 
        __FLOATING_ONLY__(T, size_t) inline printNumber(T number, uint8_t digits){
            char buf[40];
            return write(ftoa(number, buf, digits));
        }
 
        template<typename T, typename... P> inline size_t _println(T v, P... args){
            size_t n = print(v, args...);
            n += println();
            return n;
        }
    protected:
        void setWriteError(int err = 1) {
            write_error = err;
        }
    public:
        Print() {}
 
        int getWriteError() {
            return write_error;
        }
 
        void clearWriteError() {
            setWriteError(0);
        }
 
        virtual size_t write(uint8_t byte) = 0;
 
        size_t write(const char *str) {
            if(str == NULL)
                return 0;
            return write((const uint8_t *) str, strlen(str));
        }
 
        virtual size_t write(const uint8_t *buffer, size_t size);
 
        size_t write(const char *buffer, size_t size) {
            return write((const uint8_t *) buffer, size);
        }
 
        __INTEGER_ONLY__(T, size_t) inline write(T val){ return write((uint8_t)val); }
 
        /*// These handle ambiguity for write(0) case, because (0) can be a pointer or an integer
        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); }
        inline size_t write(long long t) { return write((uint8_t)t); }
        inline size_t write(unsigned long 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); }*/
 
        // default to zero, meaning "a single write may block"
        // should be overriden by subclasses with buffering
        virtual int availableForWrite() { return INT16_MAX; }
 
        size_t printf(const char * format, ...)  __attribute__ ((format (printf, 2, 3)));
#ifdef String_class_h
 
        size_t print(const String &s);
#endif
 
        size_t print(const char str[]);
 
        size_t print(char c);
 
        __SIGNED_INTEGER_ONLY__(T, size_t) print(T n, int base = DEC){
            int t = 0;
            if (base == 10 && n < 0) {
                t = print('-');
                n = -n;
            }
            return printNumber(static_cast<typename std::make_unsigned<T>::type>(n), base) + t;
        }
 
        __UNSIGNED_INTEGER_ONLY__(T, size_t) print(T n, int base = DEC){
            if (base == 0) {
                return write(n);
            }
            return printNumber(n, base);
        }
 
 
        //Removed, because constexpr is not allowed in this version of C++
        /*__INTEGER_ONLY__(T, size_t) print(T n, int base = DEC){
            if constexpr (std::is_signed<T>::value && !std::is_same<T, bool>::value){
                int t = 0;
                if (base == 10 && n < 0) {
                    t = print('-');
                    n = -n;
                }
                return printNumber(static_cast<typename std::make_unsigned<T>::type>(n), base) + t;
            }
            else{
                if (base == 0) {
                    return write(n);
                }
                return printNumber(n, base);
            }
        }*/
 
        /*size_t print(unsigned char, int = DEC);
        size_t print(int, int = DEC);
        size_t print(unsigned int, int = DEC);
        size_t print(long, int = DEC);
        size_t print(unsigned long, int = DEC);
        size_t print(long long, int = DEC);
        size_t print(unsigned long long, int = DEC);*/
 
        __FLOATING_ONLY__(T, size_t) inline print(T n, int digits = 2){
            return printNumber(n, digits);
        }
        //size_t print(double, int = 2);
 
        size_t print(const Printable& x);
 
#ifdef String_class_h
 
        size_t println(const String &s);
#endif
 
        size_t println(const char[]);
 
        size_t println(char);
 
        __INTEGER_ONLY__(T, size_t) inline println(T n, int base = 10){
            return _println(n, base);
        }
        /*size_t println(unsigned char, int = DEC);
        size_t println(int, int = DEC);
        size_t println(unsigned int, int = DEC);
        size_t println(long, int = DEC);
        size_t println(unsigned long, int = DEC);
        size_t println(long long, int = DEC);
        size_t println(unsigned long long, int = DEC);*/
 
        __FLOATING_ONLY__(T, size_t) inline println(T n, int digits = 2){
            return _println(n, digits);
        }
        //template<typename T> typename std::enable_if<std::is_floating_point<T>::value, size_t>::type println(T n, int digits = 2);
        //size_t println(double, int = 2);
 
        size_t println(const Printable&);
 
        size_t println(void);
 
 
        template<class T> inline Print& operator <<(T value) { print(value); return *this; }
};
 
 
#endif