Print.h

Go to the documentation of this file.

/* $Id: Print.h 1156 2011-06-07 04:01:16Z bhagman $
||
|| @author         Hernando Barragan <b@wiring.org.co>
|| @url            http://wiring.org.co/
|| @contribution   Nicholas Zambetti
|| @contribution   Brett Hagman <bhagman@wiring.org.co>
|| @contribution   Alexander Brevig <abrevig@wiring.org.co>
||
|| @description
|| | Print library.
|| |
|| | Wiring Common API
|| #
||
|| @license Please see cores/Common/License.txt.
||
*/
 
#pragma once
 
#ifdef __cplusplus
 
#include "Printable.h"
#include "WString.h"
 
#define INITIAL_PRINTF_BUFFSIZE 128
 
class Print
{
public:
    Print() = default;
 
    Print(const Print&) = delete;
    Print(Print&&) = delete;
 
    virtual ~Print() = default;
 
    Print& operator=(const Print&) = delete;
    Print& operator=(Print&&) = delete;
 
    int getWriteError()
    {
        return write_error;
    }
 
    void clearWriteError()
    {
        setWriteError(0);
    }
 
    virtual size_t write(uint8_t c) = 0;
 
    size_t write(const char* str)
    {
        if(str == nullptr) {
            return 0;
        }
        return write(reinterpret_cast<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(reinterpret_cast<const uint8_t*>(buffer), size);
    }
 
    size_t print(char c)
    {
        return write(c);
    }
 
    size_t print(const char str[])
    {
        return write(str);
    }
 
    size_t print(unsigned long num, uint8_t base = DEC)
    {
        if(base == 0) {
            return write(num);
        } else {
            return printNumber(num, base);
        }
    }
 
    template <typename... Args> size_t print(unsigned long num, Args... args)
    {
        return printNumber(num, args...);
    }
 
    template <typename... Args> size_t print(const unsigned long long& num, Args... args)
    {
        return printNumber(num, args...);
    }
 
    size_t print(long num, uint8_t base = DEC)
    {
        if(base == 0) {
            return write(num);
        } else {
            return printNumber(num, base);
        }
    }
 
    template <typename... Args> size_t print(long num, Args... args)
    {
        return printNumber(num, args...);
    }
 
    template <typename... Args> size_t print(const long long& num, Args... args)
    {
        return printNumber(num, args...);
    }
 
    template <typename... Args> size_t print(unsigned int num, Args... args)
    {
        return print((unsigned long)num, args...);
    }
 
    template <typename... Args> size_t print(unsigned char num, Args... args)
    {
        return print((unsigned long)num, args...);
    }
 
    template <typename... Args> size_t print(int num, Args... args)
    {
        return printNumber((long)num, args...);
    }
    size_t print(double num, int digits = 2)
    {
        return printFloat(num, digits);
    }
 
    /*
     * Helper class using SFINAE to identify *any* class with a `printTo` method, even if not a base of `Printable`.
     *
     * https://stackoverflow.com/a/257382
     */
    template <typename T> class has_printTo
    {
        template <typename C> static uint8_t test(decltype(&C::printTo));
        template <typename C> static uint32_t test(...);
 
    public:
        enum { value = (sizeof(test<T>(0)) == 1) };
    };
 
    template <typename T> typename std::enable_if<has_printTo<T>::value, size_t>::type print(const T& obj)
    {
        return obj.printTo(*this);
    }
 
    size_t print(const String& s)
    {
        return write(s.c_str(), s.length());
    }
 
    template <typename E>
    typename std::enable_if<std::is_enum<E>::value && !std::is_convertible<E, int>::value, size_t>::type print(E value)
    {
        extern String toString(E e);
        return print(toString(value));
    }
 
    size_t println()
    {
        return write("\r\n", 2);
    }
 
    template <typename... Args> size_t println(const Args&... args)
    {
        return print(args...) + println();
    }
 
    size_t printf(const char* fmt, ...) __attribute__((format(printf, 2, 3)));
 
private:
    int write_error = 0;
    size_t printNumber(unsigned long num, uint8_t base = DEC, uint8_t width = 0, char pad = '0');
    size_t printNumber(const unsigned long long& num, uint8_t base = DEC, uint8_t width = 0, char pad = '0');
    size_t printNumber(long num, uint8_t base = DEC, uint8_t width = 0, char pad = '0');
    size_t printNumber(const long long& num, uint8_t base = DEC, uint8_t width = 0, char pad = '0');
    size_t printFloat(double num, uint8_t digits);
 
protected:
    void setWriteError(int err = 1)
    {
        write_error = err;
    }
};
 
inline Print& operator<<(Print& p, const char value[])
{
    p.print(value);
    return p;
}
 
template <typename T>
typename std::enable_if<!std::is_array<T>::value, Print&>::type operator<<(Print& p, const T& value)
{
    p.print(value);
    return p;
}
 
// Thanks to Arduino forum user Paul V. who suggested this
// clever technique to allow for expressions like
//   Serial << "Hello!" << endl;
enum EndLineCode { endl };
 
inline Print& operator<<(Print& p, EndLineCode)
{
    p.println();
    return p;
}
 
#endif // __cplusplus