Replaced printTo() with serializeJson()

* Added `serializeJson()` and `serializeJsonPretty()`
* Added `measureJson()` and `measureJsonPretty()`
* Removed `printTo()` and `prettyPrintTo()`
* Removed `measureLength()` and `measurePrettyLength()`

src/ArduinoJson/Serialization/DummyPrint.hpp

@@ -7,7 +7,7 @@
 namespace ArduinoJson {
 namespace Internals {
 
-// A dummy Print implementation used in JsonPrintable::measureLength()
+// A dummy Print implementation used in measureJson()
 class DummyPrint {
  public:
   size_t print(char) {
@@ -18,5 +18,5 @@ class DummyPrint {
     return strlen(s);
   }
 };
-}
-}
+}  // namespace Internals
+}  // namespace ArduinoJson

src/ArduinoJson/Serialization/IndentedPrint.hpp

@@ -8,7 +8,7 @@ namespace ArduinoJson {
 namespace Internals {
 
 // Decorator on top of Print to allow indented output.
-// This class is used by JsonPrintable::prettyPrintTo() but can also be used
+// This class is used by serializeJsonPretty() but can also be used
 // for your own purpose, like logging.
 template <typename Print>
 class IndentedPrint {
@@ -64,5 +64,5 @@ class IndentedPrint {
   static const int MAX_LEVEL = 15;    // because it's only 4 bits
   static const int MAX_TAB_SIZE = 7;  // because it's only 3 bits
 };
-}
-}
+}  // namespace Internals
+}  // namespace ArduinoJson

src/ArduinoJson/Serialization/JsonPrintable.hpp

@@ -1,117 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#pragma once
-
-#include "../Configuration.hpp"
-#include "../TypeTraits/EnableIf.hpp"
-#include "DummyPrint.hpp"
-#include "DynamicStringBuilder.hpp"
-#include "IndentedPrint.hpp"
-#include "JsonSerializer.hpp"
-#include "JsonWriter.hpp"
-#include "Prettyfier.hpp"
-#include "StaticStringBuilder.hpp"
-
-#if ARDUINOJSON_ENABLE_STD_STREAM
-#include "StreamPrintAdapter.hpp"
-#endif
-
-namespace ArduinoJson {
-namespace Internals {
-
-// Implements all the overloads of printTo() and prettyPrintTo()
-// Caution: this class use a template parameter to avoid virtual methods.
-// This is a bit curious but allows to reduce the size of JsonVariant, JsonArray
-// and JsonObject.
-template <typename T>
-class JsonPrintable {
- public:
-  template <typename Print>
-  typename EnableIf<!StringTraits<Print>::has_append, size_t>::type printTo(
-      Print &print) const {
-    JsonWriter<Print> writer(print);
-    JsonSerializer<JsonWriter<Print> >::serialize(downcast(), writer);
-    return writer.bytesWritten();
-  }
-
-#if ARDUINOJSON_ENABLE_STD_STREAM
-  std::ostream &printTo(std::ostream &os) const {
-    StreamPrintAdapter adapter(os);
-    printTo(adapter);
-    return os;
-  }
-#endif
-
-  size_t printTo(char *buffer, size_t bufferSize) const {
-    StaticStringBuilder sb(buffer, bufferSize);
-    return printTo(sb);
-  }
-
-  template <size_t N>
-  size_t printTo(char (&buffer)[N]) const {
-    return printTo(buffer, N);
-  }
-
-  template <typename TString>
-  typename EnableIf<StringTraits<TString>::has_append, size_t>::type printTo(
-      TString &str) const {
-    DynamicStringBuilder<TString> sb(str);
-    return printTo(sb);
-  }
-
-  template <typename Print>
-  size_t prettyPrintTo(IndentedPrint<Print> &print) const {
-    Prettyfier<Print> p(print);
-    return printTo(p);
-  }
-
-  size_t prettyPrintTo(char *buffer, size_t bufferSize) const {
-    StaticStringBuilder sb(buffer, bufferSize);
-    return prettyPrintTo(sb);
-  }
-
-  template <size_t N>
-  size_t prettyPrintTo(char (&buffer)[N]) const {
-    return prettyPrintTo(buffer, N);
-  }
-
-  template <typename Print>
-  typename EnableIf<!StringTraits<Print>::has_append, size_t>::type
-  prettyPrintTo(Print &print) const {
-    IndentedPrint<Print> indentedPrint(print);
-    return prettyPrintTo(indentedPrint);
-  }
-
-  template <typename TString>
-  typename EnableIf<StringTraits<TString>::has_append, size_t>::type
-  prettyPrintTo(TString &str) const {
-    DynamicStringBuilder<TString> sb(str);
-    return prettyPrintTo(sb);
-  }
-
-  size_t measureLength() const {
-    DummyPrint dp;
-    return printTo(dp);
-  }
-
-  size_t measurePrettyLength() const {
-    DummyPrint dp;
-    return prettyPrintTo(dp);
-  }
-
- private:
-  const T &downcast() const {
-    return *static_cast<const T *>(this);
-  }
-};
-
-#if ARDUINOJSON_ENABLE_STD_STREAM
-template <typename T>
-inline std::ostream &operator<<(std::ostream &os, const JsonPrintable<T> &v) {
-  return v.printTo(os);
-}
-#endif
-}
-}

src/ArduinoJson/Serialization/JsonSerializer.hpp

@@ -4,7 +4,16 @@
 
 #pragma once
 
+#include "DummyPrint.hpp"
+#include "DynamicStringBuilder.hpp"
+#include "IndentedPrint.hpp"
 #include "JsonWriter.hpp"
+#include "Prettyfier.hpp"
+#include "StaticStringBuilder.hpp"
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+#include "StreamPrintAdapter.hpp"
+#endif
 
 namespace ArduinoJson {
 
@@ -28,5 +37,122 @@ class JsonSerializer {
   static void serialize(const JsonObjectSubscript<TKey> &, Writer &);
   static void serialize(const JsonVariant &, Writer &);
 };
+}  // namespace Internals
+
+template <typename TSource, typename TDestination>
+typename Internals::EnableIf<!Internals::StringTraits<TDestination>::has_append,
+                             size_t>::type
+serializeJson(const TSource &source, TDestination &destination) {
+  Internals::JsonWriter<TDestination> writer(destination);
+  Internals::JsonSerializer<Internals::JsonWriter<TDestination> >::serialize(
+      source, writer);
+  return writer.bytesWritten();
 }
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+template <typename TSource>
+std::ostream &serializeJson(const TSource &source, std::ostream &os) {
+  Internals::StreamPrintAdapter adapter(os);
+  serializeJson(source, adapter);
+  return os;
 }
+#endif
+
+template <typename TSource>
+size_t serializeJson(const TSource &source, char *buffer, size_t bufferSize) {
+  Internals::StaticStringBuilder sb(buffer, bufferSize);
+  return serializeJson(source, sb);
+}
+
+template <typename TSource, size_t N>
+size_t serializeJson(const TSource &source, char (&buffer)[N]) {
+  return serializeJson(source, buffer, N);
+}
+
+template <typename TSource, typename TDestination>
+typename Internals::EnableIf<Internals::StringTraits<TDestination>::has_append,
+                             size_t>::type
+serializeJson(const TSource &source, TDestination &str) {
+  Internals::DynamicStringBuilder<TDestination> sb(str);
+  return serializeJson(source, sb);
+}
+
+template <typename TSource, typename TDestination>
+size_t serializeJsonPretty(const TSource &source,
+                           Internals::IndentedPrint<TDestination> &print) {
+  Internals::Prettyfier<TDestination> p(print);
+  return serializeJson(source, p);
+}
+
+template <typename TSource>
+size_t serializeJsonPretty(const TSource &source, char *buffer,
+                           size_t bufferSize) {
+  Internals::StaticStringBuilder sb(buffer, bufferSize);
+  return serializeJsonPretty(source, sb);
+}
+
+template <typename TSource, size_t N>
+size_t serializeJsonPretty(const TSource &source, char (&buffer)[N]) {
+  return serializeJsonPretty(source, buffer, N);
+}
+
+template <typename TSource, typename TDestination>
+typename Internals::EnableIf<!Internals::StringTraits<TDestination>::has_append,
+                             size_t>::type
+serializeJsonPretty(const TSource &source, TDestination &print) {
+  Internals::IndentedPrint<TDestination> indentedPrint(print);
+  return serializeJsonPretty(source, indentedPrint);
+}
+
+template <typename TSource, typename TDestination>
+typename Internals::EnableIf<Internals::StringTraits<TDestination>::has_append,
+                             size_t>::type
+serializeJsonPretty(const TSource &source, TDestination &str) {
+  Internals::DynamicStringBuilder<TDestination> sb(str);
+  return serializeJsonPretty(source, sb);
+}
+
+template <typename TSource>
+size_t measureJson(const TSource &source) {
+  Internals::DummyPrint dp;
+  return serializeJson(source, dp);
+}
+
+template <typename TSource>
+size_t measureJsonPretty(const TSource &source) {
+  Internals::DummyPrint dp;
+  return serializeJsonPretty(source, dp);
+}
+
+#if ARDUINOJSON_ENABLE_STD_STREAM
+inline std::ostream &operator<<(std::ostream &os, const JsonArray &source) {
+  serializeJson(source, os);
+  return os;
+}
+inline std::ostream &operator<<(std::ostream &os, const JsonObject &source) {
+  serializeJson(source, os);
+  return os;
+}
+inline std::ostream &operator<<(std::ostream &os, const JsonVariant &source) {
+  serializeJson(source, os);
+  return os;
+}
+
+namespace Internals {
+inline std::ostream &operator<<(std::ostream &os,
+                                const JsonArraySubscript &source) {
+  serializeJson(source, os);
+  return os;
+}
+
+template <typename TKey>
+inline std::ostream &operator<<(std::ostream &os,
+                                const JsonObjectSubscript<TKey> &source) {
+  serializeJson(source, os);
+  return os;
+}
+}  // namespace Internals
+
+#endif
+
+}  // namespace ArduinoJson

src/ArduinoJson/Serialization/JsonWriter.hpp

@@ -26,8 +26,6 @@ class JsonWriter {
   explicit JsonWriter(Print &sink) : _sink(sink), _length(0) {}
 
   // Returns the number of bytes sent to the Print implementation.
-  // This is very handy for implementations of printTo() that must return the
-  // number of bytes written.
   size_t bytesWritten() const {
     return _length;
   }
@@ -151,5 +149,5 @@ class JsonWriter {
  private:
   JsonWriter &operator=(const JsonWriter &);  // cannot be assigned
 };
-}
-}
+}  // namespace Internals
+}  // namespace ArduinoJson