Replace serializeJson()'s template parameter with JsonVariantConst

src/ArduinoJson/Json/JsonSerializer.hpp

@@ -116,18 +116,17 @@ class JsonSerializer : public Visitor<size_t> {
   TextFormatter<TWriter> _formatter;
 };
 
-template <typename TSource, typename TDestination>
-size_t serializeJson(const TSource &source, TDestination &destination) {
+template <typename TDestination>
+size_t serializeJson(VariantConstRef source, TDestination &destination) {
   return serialize<JsonSerializer>(source, destination);
 }
 
-template <typename TSource>
-size_t serializeJson(const TSource &source, void *buffer, size_t bufferSize) {
+inline size_t serializeJson(VariantConstRef source, void *buffer,
+                            size_t bufferSize) {
   return serialize<JsonSerializer>(source, buffer, bufferSize);
 }
 
-template <typename TSource>
-size_t measureJson(const TSource &source) {
+inline size_t measureJson(VariantConstRef source) {
   return measure<JsonSerializer>(source);
 }
 

src/ArduinoJson/Json/PrettyJsonSerializer.hpp

@@ -70,19 +70,17 @@ class PrettyJsonSerializer : public JsonSerializer<TWriter> {
   uint8_t _nesting;
 };
 
-template <typename TSource, typename TDestination>
-size_t serializeJsonPretty(const TSource &source, TDestination &destination) {
+template <typename TDestination>
+size_t serializeJsonPretty(VariantConstRef source, TDestination &destination) {
   return serialize<PrettyJsonSerializer>(source, destination);
 }
 
-template <typename TSource>
-size_t serializeJsonPretty(const TSource &source, void *buffer,
+inline size_t serializeJsonPretty(VariantConstRef source, void *buffer,
                                   size_t bufferSize) {
   return serialize<PrettyJsonSerializer>(source, buffer, bufferSize);
 }
 
-template <typename TSource>
-size_t measureJsonPretty(const TSource &source) {
+inline size_t measureJsonPretty(VariantConstRef source) {
   return measure<PrettyJsonSerializer>(source);
 }
 

src/ArduinoJson/MsgPack/MsgPackSerializer.hpp

@@ -197,19 +197,17 @@ class MsgPackSerializer : public Visitor<size_t> {
   CountingDecorator<TWriter> _writer;
 };
 
-template <typename TSource, typename TDestination>
-inline size_t serializeMsgPack(const TSource& source, TDestination& output) {
+template <typename TDestination>
+inline size_t serializeMsgPack(VariantConstRef source, TDestination& output) {
   return serialize<MsgPackSerializer>(source, output);
 }
 
-template <typename TSource>
-inline size_t serializeMsgPack(const TSource& source, void* output,
+inline size_t serializeMsgPack(VariantConstRef source, void* output,
                                size_t size) {
   return serialize<MsgPackSerializer>(source, output, size);
 }
 
-template <typename TSource>
-inline size_t measureMsgPack(const TSource& source) {
+inline size_t measureMsgPack(VariantConstRef source) {
   return measure<MsgPackSerializer>(source);
 }
 

src/ArduinoJson/Serialization/measure.hpp

@@ -8,8 +8,8 @@
 
 namespace ARDUINOJSON_NAMESPACE {
 
-template <template <typename> class TSerializer, typename TSource>
-size_t measure(const TSource &source) {
+template <template <typename> class TSerializer>
+size_t measure(VariantConstRef source) {
   DummyWriter dp;
   TSerializer<DummyWriter> serializer(dp);
   return source.accept(serializer);

src/ArduinoJson/Serialization/serialize.hpp

@@ -8,30 +8,28 @@
 
 namespace ARDUINOJSON_NAMESPACE {
 
-template <template <typename> class TSerializer, typename TSource,
-          typename TWriter>
-size_t doSerialize(const TSource &source, TWriter writer) {
+template <template <typename> class TSerializer, typename TWriter>
+size_t doSerialize(VariantConstRef source, TWriter writer) {
   TSerializer<TWriter> serializer(writer);
   return source.accept(serializer);
 }
 
-template <template <typename> class TSerializer, typename TSource,
-          typename TDestination>
-size_t serialize(const TSource &source, TDestination &destination) {
+template <template <typename> class TSerializer, typename TDestination>
+size_t serialize(VariantConstRef source, TDestination &destination) {
   Writer<TDestination> writer(destination);
   return doSerialize<TSerializer>(source, writer);
 }
 
-template <template <typename> class TSerializer, typename TSource>
+template <template <typename> class TSerializer>
 typename enable_if<!TSerializer<StaticStringWriter>::producesText, size_t>::type
-serialize(const TSource &source, void *buffer, size_t bufferSize) {
+serialize(VariantConstRef source, void *buffer, size_t bufferSize) {
   StaticStringWriter writer(reinterpret_cast<char *>(buffer), bufferSize);
   return doSerialize<TSerializer>(source, writer);
 }
 
-template <template <typename> class TSerializer, typename TSource>
+template <template <typename> class TSerializer>
 typename enable_if<TSerializer<StaticStringWriter>::producesText, size_t>::type
-serialize(const TSource &source, void *buffer, size_t bufferSize) {
+serialize(VariantConstRef source, void *buffer, size_t bufferSize) {
   StaticStringWriter writer(reinterpret_cast<char *>(buffer), bufferSize);
   size_t n = doSerialize<TSerializer>(source, writer);
   // add null-terminator for text output (not counted in the size)
@@ -40,14 +38,13 @@ serialize(const TSource &source, void *buffer, size_t bufferSize) {
   return n;
 }
 
-template <template <typename> class TSerializer, typename TSource,
-          typename TChar, size_t N>
+template <template <typename> class TSerializer, typename TChar, size_t N>
 #if defined _MSC_VER && _MSC_VER < 1900
 typename enable_if<sizeof(remove_reference<TChar>::type) == 1, size_t>::type
 #else
 typename enable_if<sizeof(TChar) == 1, size_t>::type
 #endif
-serialize(const TSource &source, TChar (&buffer)[N]) {
+serialize(VariantConstRef source, TChar (&buffer)[N]) {
   return serialize<TSerializer>(source, buffer, N);
 }