Templatized all functions using String or std::string

* Removed `ArduinoJson::String`
* Removed `JsonVariant::defaultValue<T>()`
* Removed non-template `JsonObject::get()` and `JsonArray.get()`
* Fixed support for `StringSumHelper` (issue #184)
* Replaced `ARDUINOJSON_USE_ARDUINO_STRING` by `ARDUINOJSON_ENABLE_STD_STRING` and `ARDUINOJSON_ENABLE_ARDUINO_STRING` (issue #378)
* Added example `StringExample.ino` to show where `String` can be used

include/ArduinoJson/Internals/DynamicStringBuilder.hpp

@@ -8,26 +8,26 @@
 #pragma once
 
 #include "../Print.hpp"
-#include "../String.hpp"
+#include "StringFuncs.hpp"
 
 namespace ArduinoJson {
 namespace Internals {
 
 // A Print implementation that allows to write in a String
+template <typename TString>
 class DynamicStringBuilder : public Print {
  public:
-  DynamicStringBuilder(String &str) : _str(str) {}
+  DynamicStringBuilder(TString &str) : _str(str) {}
 
   virtual size_t write(uint8_t c) {
-    // Need to cast to char, otherwise String will print a number (issue #120)
-    _str += static_cast<char>(c);
+    StringFuncs<TString>::append(_str, static_cast<char>(c));
     return 1;
   }
 
  private:
   DynamicStringBuilder &operator=(const DynamicStringBuilder &);
 
-  String &_str;
+  TString &_str;
 };
 }
 }

include/ArduinoJson/Internals/JsonPrintable.hpp

@@ -8,6 +8,7 @@
 #pragma once
 
 #include "../Configuration.hpp"
+#include "../TypeTraits/EnableIf.hpp"
 #include "DummyPrint.hpp"
 #include "DynamicStringBuilder.hpp"
 #include "IndentedPrint.hpp"
@@ -49,8 +50,10 @@ class JsonPrintable {
     return printTo(sb);
   }
 
-  size_t printTo(String &str) const {
-    DynamicStringBuilder sb(str);
+  template <typename TString>
+  typename TypeTraits::EnableIf<StringFuncs<TString>::has_append, size_t>::type
+  printTo(TString &str) const {
+    DynamicStringBuilder<TString> sb(str);
     return printTo(sb);
   }
 
@@ -69,8 +72,10 @@ class JsonPrintable {
     return prettyPrintTo(indentedPrint);
   }
 
-  size_t prettyPrintTo(String &str) const {
-    DynamicStringBuilder sb(str);
+  template <typename TString>
+  typename TypeTraits::EnableIf<StringFuncs<TString>::has_append, size_t>::type
+  prettyPrintTo(TString &str) const {
+    DynamicStringBuilder<TString> sb(str);
     return prettyPrintTo(sb);
   }
 

include/ArduinoJson/Internals/JsonVariantDefault.hpp

@@ -0,0 +1,26 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Internals {
+
+template <typename T>
+struct JsonVariantDefault {
+  static T get() {
+    return T();
+  }
+};
+
+template <typename T>
+struct JsonVariantDefault<const T> : JsonVariantDefault<T> {};
+
+template <typename T>
+struct JsonVariantDefault<T&> : JsonVariantDefault<T> {};
+}
+}

include/ArduinoJson/Internals/StringFuncs.hpp

@@ -0,0 +1,94 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "../Configuration.hpp"
+
+#if ARDUINOJSON_ENABLE_ARDUINO_STRING
+#include <WString.h>
+#endif
+
+#if ARDUINOJSON_ENABLE_STD_STRING
+#include <string>
+#endif
+
+namespace ArduinoJson {
+namespace Internals {
+
+template <typename TString>
+struct StringFuncs {};
+
+template <typename TString>
+struct StringFuncs<const TString> : StringFuncs<TString> {};
+
+template <typename TString>
+struct StringFuncs<TString&> : StringFuncs<TString> {};
+
+struct CharPtrFuncs {
+  static bool equals(const char* str, const char* expected) {
+    return strcmp(str, expected) == 0;
+  }
+
+  template <typename Buffer>
+  static char* duplicate(const char* str, Buffer* buffer) {
+    if (!str) return NULL;
+    size_t size = strlen(str) + 1;
+    void* dup = buffer->alloc(size);
+    if (dup != NULL) memcpy(dup, str, size);
+    return static_cast<char*>(dup);
+  }
+
+  static const bool has_append = false;
+  static const bool should_duplicate = false;
+};
+
+template <>
+struct StringFuncs<const char*> : CharPtrFuncs {};
+
+template <>
+struct StringFuncs<char*> : CharPtrFuncs {};
+
+template <size_t N>
+struct StringFuncs<char[N]> : CharPtrFuncs {};
+
+template <typename TString>
+struct StdStringFuncs {
+  template <typename Buffer>
+  static char* duplicate(const TString& str, Buffer* buffer) {
+    if (!str.c_str()) return NULL;  // <- Arduino string can return NULL
+    size_t size = str.length() + 1;
+    void* dup = buffer->alloc(size);
+    if (dup != NULL) memcpy(dup, str.c_str(), size);
+    return static_cast<char*>(dup);
+  }
+
+  static bool equals(const TString& str, const char* expected) {
+    return str == expected;
+  }
+
+  static void append(TString& str, char c) {
+    str += c;
+  }
+
+  static const bool has_append = true;
+  static const bool should_duplicate = true;
+};
+
+#if ARDUINOJSON_ENABLE_ARDUINO_STRING
+template <>
+struct StringFuncs<String> : StdStringFuncs<String> {};
+template <>
+struct StringFuncs<StringSumHelper> : StdStringFuncs<StringSumHelper> {};
+#endif
+
+#if ARDUINOJSON_ENABLE_STD_STRING
+template <>
+struct StringFuncs<std::string> : StdStringFuncs<std::string> {};
+#endif
+}
+}

include/ArduinoJson/Internals/ValueSetter.hpp

@@ -0,0 +1,41 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "../JsonBuffer.hpp"
+#include "../JsonVariant.hpp"
+#include "../TypeTraits/EnableIf.hpp"
+#include "StringFuncs.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+template <typename TSource, typename Enable = void>
+struct ValueSetter {
+  template <typename TDestination>
+  static bool set(JsonBuffer*, TDestination& destination,
+                  const TSource& source) {
+    destination = source;
+    return true;
+  }
+};
+
+template <typename TSource>
+struct ValueSetter<TSource, typename TypeTraits::EnableIf<
+                                StringFuncs<TSource>::should_duplicate>::type> {
+  template <typename TDestination>
+  static bool set(JsonBuffer* buffer, TDestination& destination,
+                  const TSource& source) {
+    const char* copy = buffer->strdup(source);
+    if (!copy) return false;
+    destination = copy;
+    return true;
+  }
+};
+}
+}