WIP: Custom formatters

This allows passing formatters to print. E.g. instead of print(10, HEX),
you can pass any object that has a suitable printTo(Print*, ValueT)
method.

This is a WIP on top of the variadic print PR and it makes some changes
that should probably go into there.

As an example of usage:

	struct EvenOddFormatter {
	  int printTo(Print *p, int x) {
	    return p->print(x % 2 ? "odd" : "even");
	  }
	};

	Serial.println(1, EvenOddFormatter());

Author: matthijskooijman

Diff for: hardware/arduino/avr/cores/arduino/Print.cpp

@@ -41,7 +41,7 @@ size_t Print::write(const uint8_t *buffer, size_t size)
   return n;
 }
 
-size_t Print::print(const __FlashStringHelper *ifsh)
+size_t Print::doPrint(const __FlashStringHelper *ifsh)
 {
   PGM_P p = reinterpret_cast<PGM_P>(ifsh);
   size_t n = 0;
@@ -54,12 +54,12 @@ size_t Print::print(const __FlashStringHelper *ifsh)
   return n;
 }
 
-size_t Print::print(const String &s)
+size_t Print::doPrint(const String &s)
 {
   return write(s.c_str(), s.length());
 }
 
-size_t Print::print(signed long n, int base)
+size_t Print::doPrint(signed long n, int base)
 {
   if (base == 0) {
     return write(n);
@@ -75,13 +75,13 @@ size_t Print::print(signed long n, int base)
   }
 }
 
-size_t Print::print(unsigned long n, int base)
+size_t Print::doPrint(unsigned long n, int base)
 {
   if (base == 0) return write(n);
   else return printNumber(n, base);
 }
 
-size_t Print::print(double n, int digits)
+size_t Print::doPrint(double n, int digits)
 {
   return printFloat(n, digits);
 }

Diff for: hardware/arduino/avr/cores/arduino/Print.h

@@ -57,45 +57,63 @@ class Print
       return write((const uint8_t *)buffer, size);
     }
 
-    size_t print(const __FlashStringHelper *);
-    size_t print(const String &);
-    size_t print(  signed long, int = DEC);
-    size_t print(unsigned long, int = DEC);
-    size_t print(double, int = 2);
+    size_t doPrint(const __FlashStringHelper *);
+    size_t doPrint(const String &);
+    size_t doPrint(  signed long, int = DEC);
+    size_t doPrint(unsigned long, int = DEC);
+    size_t doPrint(double, int = 2);
 
-    _always_inline size_t print(const char str[])   { return write(str); }
-    _always_inline size_t print(const char c)       { return write(c); }
-    _always_inline size_t print(const Printable &x) { return x.printTo(*this); }
-    
-    _always_inline size_t print(  signed char  n, int f = DEC) { return print((  signed long) n, f); }
-    _always_inline size_t print(  signed short n, int f = DEC) { return print((  signed long) n, f); }
-    _always_inline size_t print(  signed int   n, int f = DEC) { return print((  signed long) n, f); }
-    _always_inline size_t print(unsigned char  n, int f = DEC) { return print((unsigned long) n, f); }
-    _always_inline size_t print(unsigned short n, int f = DEC) { return print((unsigned long) n, f); }
-    _always_inline size_t print(unsigned int   n, int f = DEC) { return print((unsigned long) n, f); }
-    _always_inline size_t print(    float      n, int f = 2  ) { return print((    double   ) n, f); }
+    _always_inline size_t doPrint(const char str[])   { return write(str); }
+    _always_inline size_t doPrint(const char c)       { return write(c); }
+    _always_inline size_t doPrint(const Printable &x) { return x.printTo(*this); }
 
+    _always_inline size_t doPrint(  signed char  n, int f = DEC) { return doPrint((  signed long) n, f); }
+    _always_inline size_t doPrint(  signed short n, int f = DEC) { return doPrint((  signed long) n, f); }
+    _always_inline size_t doPrint(  signed int   n, int f = DEC) { return doPrint((  signed long) n, f); }
+    _always_inline size_t doPrint(unsigned char  n, int f = DEC) { return doPrint((unsigned long) n, f); }
+    _always_inline size_t doPrint(unsigned short n, int f = DEC) { return doPrint((unsigned long) n, f); }
+    _always_inline size_t doPrint(unsigned int   n, int f = DEC) { return doPrint((unsigned long) n, f); }
+    _always_inline size_t doPrint(    float      n, int f = 2  ) { return doPrint((    double   ) n, f); }
+
+    template <typename Check, typename T>
+    struct check_type {
+      using type = T;
+    };
+    template <typename Check, typename T> using check_type_t = typename check_type<Check, T>::type;
+
+    template<typename T, typename F>
+    _always_inline auto doPrint(T v, F f )
+    -> check_type_t<decltype(f.printTo(this, v)), size_t> {
+      return f.printTo(this, v);
+    }
+ 
     size_t println(void);
 
 #if __cplusplus >= 201103L
     template<typename ...Ts> _always_inline size_t println(const Ts &...args) { size_t t = print(args...); return t + println(); }
 #else
     template<typename T> _always_inline size_t println(const T &arg)      { size_t t = print(arg);  return t + println(); }
-    template<typename T> _always_inline size_t println(const T &n, int f) { size_t t = print(n, f); return t + println(); }
+    template<typename T, typename T2> _always_inline size_t println(const T &arg1, const T2& arg2) { size_t t = print(arg1, arg2); return t + println(); }
 #endif // __cplusplus >= 201103L
 
 
+    _always_inline size_t print() { return 0; }
+
     /** Variadic methods **/
 #if __cplusplus >= 201103L  // requires C++11
-    // Ensure there are at least two parameters to avoid infinite recursion.
-    // e.g. `StringSumHelper s; print(s)` may be treated as `print(s, ...)` 
-    // with `...` being the empty list, thus calling `print(s)` again.
-    // (This is because print(StringSumHelper) isn't explicitly defined.)
+    template<typename T, typename ...Ts>
+    _always_inline size_t print(const T &arg, const Ts &...args) {
+      size_t t = doPrint(arg);
+      return t + print(args...);
+    }
+
     template<typename T, typename T2, typename ...Ts>
-    _always_inline size_t print(const T &arg, const T2 &arg2, const Ts &...args) {
-      size_t t = print(arg);
-      return t + print(arg2, args...);
+    _always_inline auto print(const T &arg, const T2 &arg2, const Ts &...args)
+    -> check_type_t<decltype(doPrint(arg, arg2)), size_t> {
+      size_t t = doPrint(arg, arg2);
+      return t + print(args...);
     }
+/*
     // Some methods take an extra int parameter.  If so, use these templates.
     // In a future, it would be nice to make the base/precision a special type.
     template<typename ...Ts> _always_inline size_t print(  signed char  n, int f, const Ts &...args) { size_t t = print(n, f); return t + print(args...); }
@@ -108,6 +126,10 @@ class Print
     template<typename ...Ts> _always_inline size_t print(unsigned long  n, int f, const Ts &...args) { size_t t = print(n, f); return t + print(args...); }
     template<typename ...Ts> _always_inline size_t print(    float      n, int f, const Ts &...args) { size_t t = print(n, f); return t + print(args...); }
     template<typename ...Ts> _always_inline size_t print(    double     n, int f, const Ts &...args) { size_t t = print(n, f); return t + print(args...); }
+*/
+#else
+    template<typename T> _always_inline size_t print(const T &arg)      { return doPrint(arg); }
+    template<typename T, typename T2> _always_inline size_t print(const T &arg1, const T2& arg2) { return doPrint(arg1, arg2); }
 #endif // __cplusplus >= 201103L
 };