Clang-format: set DerivePointerAlignment to false

2025-10-31 08:42:39 +01:00 · 2022-08-09 16:52:17 +02:00
parent 62e83133cd
commit 8002722f3b
53 changed files with 514 additions and 513 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -5,6 +5,7 @@ Standard: Cpp03
 AllowShortFunctionsOnASingleLine: Empty
 IncludeBlocks: Preserve
 IndentPPDirectives: AfterHash
+DerivePointerAlignment: false

 # Always break after if to get accurate coverage
 AllowShortIfStatementsOnASingleLine: false
--- a/extras/fuzzing/json_fuzzer.cpp
+++ b/extras/fuzzing/json_fuzzer.cpp
@@ -1,6 +1,6 @@
 #include <ArduinoJson.h>

-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
  DynamicJsonDocument doc(4096);
  DeserializationError error = deserializeJson(doc, data, size);
  if (!error) {
--- a/extras/fuzzing/msgpack_fuzzer.cpp
+++ b/extras/fuzzing/msgpack_fuzzer.cpp
@@ -1,6 +1,6 @@
 #include <ArduinoJson.h>

-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
  DynamicJsonDocument doc(4096);
  DeserializationError error = deserializeMsgPack(doc, data, size);
  if (!error) {
--- a/extras/tests/JsonArray/std_string.cpp
+++ b/extras/tests/JsonArray/std_string.cpp
@@ -5,8 +5,8 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>

-static void eraseString(std::string &str) {
-  char *p = const_cast<char *>(str.c_str());
+static void eraseString(std::string& str) {
+  char* p = const_cast<char*>(str.c_str());
  while (*p) *p++ = '*';
 }

--- a/extras/tests/JsonDocument/ElementProxy.cpp
+++ b/extras/tests/JsonDocument/ElementProxy.cpp
@@ -10,7 +10,7 @@ using namespace ARDUINOJSON_NAMESPACE;
 TEST_CASE("ElementProxy::add()") {
  DynamicJsonDocument doc(4096);
  doc.add();
-  ElementProxy<JsonDocument &> ep = doc[0];
+  ElementProxy<JsonDocument&> ep = doc[0];

  SECTION("add(int)") {
    ep.add(42);
@@ -36,7 +36,7 @@ TEST_CASE("ElementProxy::add()") {
 TEST_CASE("ElementProxy::clear()") {
  DynamicJsonDocument doc(4096);
  doc.add();
-  ElementProxy<JsonDocument &> ep = doc[0];
+  ElementProxy<JsonDocument&> ep = doc[0];

  SECTION("size goes back to zero") {
    ep.add(42);
@@ -96,7 +96,7 @@ TEST_CASE("ElementProxy::operator==()") {
 TEST_CASE("ElementProxy::remove()") {
  DynamicJsonDocument doc(4096);
  doc.add();
-  ElementProxy<JsonDocument &> ep = doc[0];
+  ElementProxy<JsonDocument&> ep = doc[0];

  SECTION("remove(int)") {
    ep.add(1);
@@ -143,7 +143,7 @@ TEST_CASE("ElementProxy::remove()") {

 TEST_CASE("ElementProxy::set()") {
  DynamicJsonDocument doc(4096);
-  ElementProxy<JsonDocument &> ep = doc[0];
+  ElementProxy<JsonDocument&> ep = doc[0];

  SECTION("set(int)") {
    ep.set(42);
@@ -169,7 +169,7 @@ TEST_CASE("ElementProxy::set()") {
 TEST_CASE("ElementProxy::size()") {
  DynamicJsonDocument doc(4096);
  doc.add();
-  ElementProxy<JsonDocument &> ep = doc[0];
+  ElementProxy<JsonDocument&> ep = doc[0];

  SECTION("returns 0") {
    REQUIRE(ep.size() == 0);
@@ -191,7 +191,7 @@ TEST_CASE("ElementProxy::size()") {
 TEST_CASE("ElementProxy::memoryUsage()") {
  DynamicJsonDocument doc(4096);
  doc.add();
-  ElementProxy<JsonDocument &> ep = doc[0];
+  ElementProxy<JsonDocument&> ep = doc[0];

  SECTION("returns 0 for null") {
    REQUIRE(ep.memoryUsage() == 0);
@@ -205,7 +205,7 @@ TEST_CASE("ElementProxy::memoryUsage()") {

 TEST_CASE("ElementProxy::operator[]") {
  DynamicJsonDocument doc(4096);
-  ElementProxy<JsonDocument &> ep = doc[1];
+  ElementProxy<JsonDocument&> ep = doc[1];

  SECTION("set member") {
    ep["world"] = 42;
@@ -224,7 +224,7 @@ TEST_CASE("ElementProxy cast to JsonVariantConst") {
  DynamicJsonDocument doc(4096);
  doc[0] = "world";

-  const ElementProxy<JsonDocument &> ep = doc[0];
+  const ElementProxy<JsonDocument&> ep = doc[0];

  JsonVariantConst var = ep;

@@ -235,7 +235,7 @@ TEST_CASE("ElementProxy cast to JsonVariant") {
  DynamicJsonDocument doc(4096);
  doc[0] = "world";

-  ElementProxy<JsonDocument &> ep = doc[0];
+  ElementProxy<JsonDocument&> ep = doc[0];

  JsonVariant var = ep;

--- a/extras/tests/JsonDocument/MemberProxy.cpp
+++ b/extras/tests/JsonDocument/MemberProxy.cpp
@@ -9,7 +9,7 @@ using namespace ARDUINOJSON_NAMESPACE;

 TEST_CASE("MemberProxy::add()") {
  DynamicJsonDocument doc(4096);
-  MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
+  MemberProxy<JsonDocument&, const char*> mp = doc["hello"];

  SECTION("add(int)") {
    mp.add(42);
@@ -26,7 +26,7 @@ TEST_CASE("MemberProxy::add()") {

 TEST_CASE("MemberProxy::clear()") {
  DynamicJsonDocument doc(4096);
-  MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
+  MemberProxy<JsonDocument&, const char*> mp = doc["hello"];

  SECTION("size goes back to zero") {
    mp.add(42);
@@ -85,7 +85,7 @@ TEST_CASE("MemberProxy::operator==()") {

 TEST_CASE("MemberProxy::containsKey()") {
  DynamicJsonDocument doc(4096);
-  MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
+  MemberProxy<JsonDocument&, const char*> mp = doc["hello"];

  SECTION("containsKey(const char*)") {
    mp["key"] = "value";
@@ -115,9 +115,9 @@ TEST_CASE("MemberProxy::operator|()") {
  SECTION("Issue #1411") {
    doc["sensor"] = "gps";

-    const char *test = "test";  // <- the literal must be captured in a variable
+    const char* test = "test";  // <- the literal must be captured in a variable
                                // to trigger the bug
-    const char *sensor = doc["sensor"] | test;  // "gps"
+    const char* sensor = doc["sensor"] | test;  // "gps"

    REQUIRE(sensor == std::string("gps"));
  }
@@ -136,7 +136,7 @@ TEST_CASE("MemberProxy::operator|()") {

 TEST_CASE("MemberProxy::remove()") {
  DynamicJsonDocument doc(4096);
-  MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
+  MemberProxy<JsonDocument&, const char*> mp = doc["hello"];

  SECTION("remove(int)") {
    mp.add(1);
@@ -183,7 +183,7 @@ TEST_CASE("MemberProxy::remove()") {

 TEST_CASE("MemberProxy::set()") {
  DynamicJsonDocument doc(4096);
-  MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
+  MemberProxy<JsonDocument&, const char*> mp = doc["hello"];

  SECTION("set(int)") {
    mp.set(42);
@@ -208,7 +208,7 @@ TEST_CASE("MemberProxy::set()") {

 TEST_CASE("MemberProxy::size()") {
  DynamicJsonDocument doc(4096);
-  MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
+  MemberProxy<JsonDocument&, const char*> mp = doc["hello"];

  SECTION("returns 0") {
    REQUIRE(mp.size() == 0);
@@ -231,7 +231,7 @@ TEST_CASE("MemberProxy::size()") {

 TEST_CASE("MemberProxy::memoryUsage()") {
  DynamicJsonDocument doc(4096);
-  MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
+  MemberProxy<JsonDocument&, const char*> mp = doc["hello"];

  SECTION("returns 0 when null") {
    REQUIRE(mp.memoryUsage() == 0);
@@ -245,7 +245,7 @@ TEST_CASE("MemberProxy::memoryUsage()") {

 TEST_CASE("MemberProxy::operator[]") {
  DynamicJsonDocument doc(4096);
-  MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
+  MemberProxy<JsonDocument&, const char*> mp = doc["hello"];

  SECTION("set member") {
    mp["world"] = 42;
@@ -264,7 +264,7 @@ TEST_CASE("MemberProxy cast to JsonVariantConst") {
  DynamicJsonDocument doc(4096);
  doc["hello"] = "world";

-  const MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
+  const MemberProxy<JsonDocument&, const char*> mp = doc["hello"];

  JsonVariantConst var = mp;

@@ -275,7 +275,7 @@ TEST_CASE("MemberProxy cast to JsonVariant") {
  DynamicJsonDocument doc(4096);
  doc["hello"] = "world";

-  MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
+  MemberProxy<JsonDocument&, const char*> mp = doc["hello"];

  JsonVariant var = mp;

--- a/extras/tests/JsonObject/std_string.cpp
+++ b/extras/tests/JsonObject/std_string.cpp
@@ -5,8 +5,8 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>

-static void eraseString(std::string &str) {
-  char *p = const_cast<char *>(str.c_str());
+static void eraseString(std::string& str) {
+  char* p = const_cast<char*>(str.c_str());
  while (*p) *p++ = '*';
 }

--- a/extras/tests/JsonSerializer/CustomWriter.cpp
+++ b/extras/tests/JsonSerializer/CustomWriter.cpp
@@ -14,18 +14,18 @@ class CustomWriter {
    return 1;
  }

-  size_t write(const uint8_t *s, size_t n) {
-    _str.append(reinterpret_cast<const char *>(s), n);
+  size_t write(const uint8_t* s, size_t n) {
+    _str.append(reinterpret_cast<const char*>(s), n);
    return n;
  }

-  const std::string &str() const {
+  const std::string& str() const {
    return _str;
  }

 private:
-  CustomWriter(const CustomWriter &);  // non-copiable
-  CustomWriter &operator=(const CustomWriter &);
+  CustomWriter(const CustomWriter&);  // non-copiable
+  CustomWriter& operator=(const CustomWriter&);

  std::string _str;
 };
--- a/extras/tests/JsonSerializer/JsonArray.cpp
+++ b/extras/tests/JsonSerializer/JsonArray.cpp
@@ -23,7 +23,7 @@ TEST_CASE("serializeJson(JsonArray)") {
  }

  SECTION("Null") {
-    array.add(static_cast<char *>(0));
+    array.add(static_cast<char*>(0));

    check(array, "[null]");
  }
--- a/extras/tests/JsonSerializer/JsonObject.cpp
+++ b/extras/tests/JsonSerializer/JsonObject.cpp
@@ -6,7 +6,7 @@
 #include <catch.hpp>
 #include <string>

-static void checkObject(const JsonObject obj, const std::string &expected) {
+static void checkObject(const JsonObject obj, const std::string& expected) {
  char actual[256];
  memset(actual, '!', sizeof(actual));

@@ -84,8 +84,8 @@ TEST_CASE("serializeJson(JsonObject)") {
  }

  SECTION("TwoNull") {
-    obj["a"] = static_cast<char *>(0);
-    obj["b"] = static_cast<char *>(0);
+    obj["a"] = static_cast<char*>(0);
+    obj["b"] = static_cast<char*>(0);
    checkObject(obj, "{\"a\":null,\"b\":null}");
  }

--- a/extras/tests/JsonSerializer/JsonVariant.cpp
+++ b/extras/tests/JsonSerializer/JsonVariant.cpp
@@ -7,7 +7,7 @@
 #include <limits>

 template <typename T>
-void check(T value, const std::string &expected) {
+void check(T value, const std::string& expected) {
  DynamicJsonDocument doc(4096);
  doc.to<JsonVariant>().set(value);
  char buffer[256] = "";
@@ -22,7 +22,7 @@ TEST_CASE("serializeJson(JsonVariant)") {
  }

  SECTION("Null string") {
-    check(static_cast<char *>(0), "null");
+    check(static_cast<char*>(0), "null");
  }

  SECTION("const char*") {
--- a/extras/tests/JsonVariant/is.cpp
+++ b/extras/tests/JsonVariant/is.cpp
@@ -19,7 +19,7 @@ TEST_CASE("JsonVariant::is<T>()") {
    CHECK(variant.is<JsonVariant>() == false);
    CHECK(variant.is<JsonVariantConst>() == false);
    CHECK(variant.is<bool>() == false);
-    CHECK(variant.is<const char *>() == false);
+    CHECK(variant.is<const char*>() == false);
    CHECK(variant.is<int>() == false);
    CHECK(variant.is<std::string>() == false);
    CHECK(variant.is<JsonString>() == false);
@@ -34,7 +34,7 @@ TEST_CASE("JsonVariant::is<T>()") {
    CHECK(variant.is<JsonObject>() == false);
    CHECK(variant.is<JsonArray>() == false);
    CHECK(variant.is<bool>() == false);
-    CHECK(variant.is<const char *>() == false);
+    CHECK(variant.is<const char*>() == false);
    CHECK(variant.is<int>() == false);
    CHECK(variant.is<std::string>() == false);
    CHECK(variant.is<JsonString>() == false);
@@ -50,7 +50,7 @@ TEST_CASE("JsonVariant::is<T>()") {
    CHECK(variant.is<JsonVariantConst>() == true);
    CHECK(variant.is<JsonObject>() == false);
    CHECK(variant.is<JsonArray>() == false);
-    CHECK(variant.is<const char *>() == false);
+    CHECK(variant.is<const char*>() == false);
    CHECK(variant.is<int>() == false);
    CHECK(variant.is<std::string>() == false);
    CHECK(variant.is<JsonString>() == false);
@@ -66,7 +66,7 @@ TEST_CASE("JsonVariant::is<T>()") {
    CHECK(variant.is<JsonVariantConst>() == true);
    CHECK(variant.is<JsonObject>() == false);
    CHECK(variant.is<JsonArray>() == false);
-    CHECK(variant.is<const char *>() == false);
+    CHECK(variant.is<const char*>() == false);
    CHECK(variant.is<int>() == false);
    CHECK(variant.is<std::string>() == false);
    CHECK(variant.is<JsonString>() == false);
@@ -88,7 +88,7 @@ TEST_CASE("JsonVariant::is<T>()") {
    CHECK(variant.is<bool>() == false);
    CHECK(variant.is<JsonObject>() == false);
    CHECK(variant.is<JsonArray>() == false);
-    CHECK(variant.is<const char *>() == false);
+    CHECK(variant.is<const char*>() == false);
    CHECK(variant.is<std::string>() == false);
    CHECK(variant.is<JsonString>() == false);
  }
@@ -103,7 +103,7 @@ TEST_CASE("JsonVariant::is<T>()") {
    CHECK(variant.is<bool>() == false);
    CHECK(variant.is<JsonObject>() == false);
    CHECK(variant.is<JsonArray>() == false);
-    CHECK(variant.is<const char *>() == false);
+    CHECK(variant.is<const char*>() == false);
    CHECK(variant.is<int>() == false);
    CHECK(variant.is<std::string>() == false);
    CHECK(variant.is<JsonString>() == false);
@@ -113,8 +113,8 @@ TEST_CASE("JsonVariant::is<T>()") {
  SECTION("const char*") {
    variant.set("4.2");

-    CHECK(variant.is<const char *>() == true);
-    CHECK(variant.is<const char *>() == true);
+    CHECK(variant.is<const char*>() == true);
+    CHECK(variant.is<const char*>() == true);
    CHECK(variant.is<std::string>() == true);
    CHECK(variant.is<JsonString>() == true);
    CHECK(variant.is<JsonVariant>() == true);
@@ -140,7 +140,7 @@ TEST_CASE("JsonVariant::is<T>()") {
    CHECK(variant.is<int>() == false);
    CHECK(variant.is<float>() == false);
    CHECK(variant.is<bool>() == false);
-    CHECK(variant.is<const char *>() == false);
+    CHECK(variant.is<const char*>() == false);
    CHECK(variant.is<MYENUM2>() == false);
  }

@@ -156,7 +156,7 @@ TEST_CASE("JsonVariant::is<T>()") {
    CHECK(variant.is<int>() == false);
    CHECK(variant.is<float>() == false);
    CHECK(variant.is<bool>() == false);
-    CHECK(variant.is<const char *>() == false);
+    CHECK(variant.is<const char*>() == false);
    CHECK(variant.is<MYENUM2>() == false);
    CHECK(variant.is<JsonVariant>() == true);
    CHECK(variant.is<JsonVariantConst>() == true);
@@ -178,7 +178,7 @@ TEST_CASE("JsonVariantConst::is<T>()") {
    CHECK(cvariant.is<JsonVariant>() == false);
    CHECK(cvariant.is<JsonVariantConst>() == false);
    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<const char *>() == false);
+    CHECK(cvariant.is<const char*>() == false);
    CHECK(cvariant.is<int>() == false);
    CHECK(cvariant.is<std::string>() == false);
    CHECK(cvariant.is<JsonString>() == false);
@@ -192,7 +192,7 @@ TEST_CASE("JsonVariantConst::is<T>()") {
    CHECK(cvariant.is<JsonArray>() == false);
    CHECK(cvariant.is<JsonVariant>() == false);
    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<const char *>() == false);
+    CHECK(cvariant.is<const char*>() == false);
    CHECK(cvariant.is<int>() == false);
    CHECK(cvariant.is<std::string>() == false);
    CHECK(cvariant.is<JsonString>() == false);
@@ -208,7 +208,7 @@ TEST_CASE("JsonVariantConst::is<T>()") {
    CHECK(cvariant.is<JsonVariant>() == false);
    CHECK(cvariant.is<JsonObject>() == false);
    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<const char *>() == false);
+    CHECK(cvariant.is<const char*>() == false);
    CHECK(cvariant.is<int>() == false);
    CHECK(cvariant.is<std::string>() == false);
    CHECK(cvariant.is<JsonString>() == false);
@@ -224,7 +224,7 @@ TEST_CASE("JsonVariantConst::is<T>()") {
    CHECK(cvariant.is<JsonVariant>() == false);
    CHECK(cvariant.is<JsonObject>() == false);
    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<const char *>() == false);
+    CHECK(cvariant.is<const char*>() == false);
    CHECK(cvariant.is<int>() == false);
    CHECK(cvariant.is<std::string>() == false);
    CHECK(cvariant.is<JsonString>() == false);
@@ -246,7 +246,7 @@ TEST_CASE("JsonVariantConst::is<T>()") {
    CHECK(cvariant.is<JsonObject>() == false);
    CHECK(cvariant.is<JsonArray>() == false);
    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<const char *>() == false);
+    CHECK(cvariant.is<const char*>() == false);
    CHECK(cvariant.is<std::string>() == false);
    CHECK(cvariant.is<JsonString>() == false);
  }
@@ -261,7 +261,7 @@ TEST_CASE("JsonVariantConst::is<T>()") {
    CHECK(cvariant.is<JsonObject>() == false);
    CHECK(cvariant.is<JsonArray>() == false);
    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<const char *>() == false);
+    CHECK(cvariant.is<const char*>() == false);
    CHECK(cvariant.is<int>() == false);
    CHECK(cvariant.is<std::string>() == false);
    CHECK(cvariant.is<JsonString>() == false);
@@ -271,8 +271,8 @@ TEST_CASE("JsonVariantConst::is<T>()") {
  SECTION("const char*") {
    variant.set("4.2");

-    CHECK(cvariant.is<const char *>() == true);
-    CHECK(cvariant.is<const char *>() == true);
+    CHECK(cvariant.is<const char*>() == true);
+    CHECK(cvariant.is<const char*>() == true);
    CHECK(cvariant.is<std::string>() == true);
    CHECK(cvariant.is<JsonString>() == true);
    CHECK(cvariant.is<double>() == false);
@@ -297,7 +297,7 @@ TEST_CASE("JsonVariantConst::is<T>()") {
    CHECK(cvariant.is<int>() == false);
    CHECK(cvariant.is<float>() == false);
    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<const char *>() == false);
+    CHECK(cvariant.is<const char*>() == false);
    CHECK(cvariant.is<MYENUM2>() == false);
  }

@@ -313,7 +313,7 @@ TEST_CASE("JsonVariantConst::is<T>()") {
    CHECK(cvariant.is<int>() == false);
    CHECK(cvariant.is<float>() == false);
    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<const char *>() == false);
+    CHECK(cvariant.is<const char*>() == false);
    CHECK(cvariant.is<MYENUM2>() == false);
  }
 }
--- a/extras/tests/JsonVariant/set.cpp
+++ b/extras/tests/JsonVariant/set.cpp
@@ -15,7 +15,7 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
    char str[16];

    strcpy(str, "hello");
-    bool result = variant.set(static_cast<const char *>(str));
+    bool result = variant.set(static_cast<const char*>(str));
    strcpy(str, "world");

    REQUIRE(result == true);
@@ -23,7 +23,7 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
  }

  SECTION("(const char*)0") {
-    bool result = variant.set(static_cast<const char *>(0));
+    bool result = variant.set(static_cast<const char*>(0));

    REQUIRE(result == true);
    REQUIRE(variant.isNull());
@@ -41,7 +41,7 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
  }

  SECTION("(char*)0") {
-    bool result = variant.set(static_cast<char *>(0));
+    bool result = variant.set(static_cast<char*>(0));

    REQUIRE(result == true);
    REQUIRE(variant.isNull());
@@ -51,7 +51,7 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
    char str[16];

    strcpy(str, "hello");
-    bool result = variant.set(reinterpret_cast<unsigned char *>(str));
+    bool result = variant.set(reinterpret_cast<unsigned char*>(str));
    strcpy(str, "world");

    REQUIRE(result == true);
@@ -62,7 +62,7 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
    char str[16];

    strcpy(str, "hello");
-    bool result = variant.set(reinterpret_cast<signed char *>(str));
+    bool result = variant.set(reinterpret_cast<signed char*>(str));
    strcpy(str, "world");

    REQUIRE(result == true);
--- a/extras/tests/JsonVariant/types.cpp
+++ b/extras/tests/JsonVariant/types.cpp
@@ -17,9 +17,9 @@ void checkValue(T expected) {
 }

 template <typename T>
-void checkReference(T &expected) {
+void checkReference(T& expected) {
  JsonVariant variant = expected;
-  REQUIRE(expected == variant.as<T &>());
+  REQUIRE(expected == variant.as<T&>());
 }

 template <typename T>
@@ -46,10 +46,10 @@ TEST_CASE("JsonVariant set()/get()") {
 #endif

  SECTION("Null") {
-    checkValue<const char *>(NULL);
+    checkValue<const char*>(NULL);
  }
  SECTION("const char*") {
-    checkValue<const char *>("hello");
+    checkValue<const char*>("hello");
  }
  SECTION("std::string") {
    checkValue<std::string>("hello");
--- a/extras/tests/MemoryPool/clear.cpp
+++ b/extras/tests/MemoryPool/clear.cpp
@@ -22,7 +22,7 @@ TEST_CASE("MemoryPool::clear()") {
  }

  SECTION("Discards allocated strings") {
-    pool.saveString(adaptString(const_cast<char *>("123456789")));
+    pool.saveString(adaptString(const_cast<char*>("123456789")));
    REQUIRE(pool.size() == 10);

    pool.clear();
--- a/extras/tests/MemoryPool/saveString.cpp
+++ b/extras/tests/MemoryPool/saveString.cpp
@@ -8,11 +8,11 @@

 using namespace ARDUINOJSON_NAMESPACE;

-static const char *saveString(MemoryPool &pool, const char *s) {
-  return pool.saveString(adaptString(const_cast<char *>(s)));
+static const char* saveString(MemoryPool& pool, const char* s) {
+  return pool.saveString(adaptString(const_cast<char*>(s)));
 }

-static const char *saveString(MemoryPool &pool, const char *s, size_t n) {
+static const char* saveString(MemoryPool& pool, const char* s, size_t n) {
  return pool.saveString(adaptString(s, n));
 }

@@ -21,36 +21,36 @@ TEST_CASE("MemoryPool::saveString()") {
  MemoryPool pool(buffer, 32);

  SECTION("Duplicates different strings") {
-    const char *a = saveString(pool, "hello");
-    const char *b = saveString(pool, "world");
+    const char* a = saveString(pool, "hello");
+    const char* b = saveString(pool, "world");
    REQUIRE(a != b);
    REQUIRE(pool.size() == 6 + 6);
  }

  SECTION("Deduplicates identical strings") {
-    const char *a = saveString(pool, "hello");
-    const char *b = saveString(pool, "hello");
+    const char* a = saveString(pool, "hello");
+    const char* b = saveString(pool, "hello");
    REQUIRE(a == b);
    REQUIRE(pool.size() == 6);
  }

  SECTION("Deduplicates identical strings that contain NUL") {
-    const char *a = saveString(pool, "hello\0world", 11);
-    const char *b = saveString(pool, "hello\0world", 11);
+    const char* a = saveString(pool, "hello\0world", 11);
+    const char* b = saveString(pool, "hello\0world", 11);
    REQUIRE(a == b);
    REQUIRE(pool.size() == 12);
  }

  SECTION("Reuse part of a string if it ends with NUL") {
-    const char *a = saveString(pool, "hello\0world", 11);
-    const char *b = saveString(pool, "hello");
+    const char* a = saveString(pool, "hello\0world", 11);
+    const char* b = saveString(pool, "hello");
    REQUIRE(a == b);
    REQUIRE(pool.size() == 12);
  }

  SECTION("Don't stop on first NUL") {
-    const char *a = saveString(pool, "hello");
-    const char *b = saveString(pool, "hello\0world", 11);
+    const char* a = saveString(pool, "hello");
+    const char* b = saveString(pool, "hello\0world", 11);
    REQUIRE(a != b);
    REQUIRE(pool.size() == 18);
  }
@@ -58,16 +58,16 @@ TEST_CASE("MemoryPool::saveString()") {
  SECTION("Returns NULL when full") {
    REQUIRE(pool.capacity() == 32);

-    const void *p1 = saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+    const void* p1 = saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
    REQUIRE(p1 != 0);
    REQUIRE(pool.size() == 32);

-    const void *p2 = saveString(pool, "b");
+    const void* p2 = saveString(pool, "b");
    REQUIRE(p2 == 0);
  }

  SECTION("Returns NULL when pool is too small") {
-    const void *p = saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+    const void* p = saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
    REQUIRE(0 == p);
  }

@@ -82,15 +82,15 @@ TEST_CASE("MemoryPool::saveString()") {
  }

  SECTION("Returns same address after clear()") {
-    const void *a = saveString(pool, "hello");
+    const void* a = saveString(pool, "hello");
    pool.clear();
-    const void *b = saveString(pool, "world");
+    const void* b = saveString(pool, "world");

    REQUIRE(a == b);
  }

  SECTION("Can use full capacity when fresh") {
-    const void *a = saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+    const void* a = saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");

    REQUIRE(a != 0);
  }
@@ -99,7 +99,7 @@ TEST_CASE("MemoryPool::saveString()") {
    saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
    pool.clear();

-    const void *a = saveString(pool, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
+    const void* a = saveString(pool, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");

    REQUIRE(a != 0);
  }
--- a/extras/tests/MsgPackSerializer/destination_types.cpp
+++ b/extras/tests/MsgPackSerializer/destination_types.cpp
@@ -9,7 +9,7 @@ TEST_CASE("serialize MsgPack to various destination types") {
  DynamicJsonDocument doc(4096);
  JsonObject object = doc.to<JsonObject>();
  object["hello"] = "world";
-  const char *expected_result = "\x81\xA5hello\xA5world";
+  const char* expected_result = "\x81\xA5hello\xA5world";
  const size_t expected_length = 13;

  SECTION("std::string") {
--- a/extras/tests/MsgPackSerializer/misc.cpp
+++ b/extras/tests/MsgPackSerializer/misc.cpp
@@ -3,7 +3,7 @@
 #include <limits>

 template <typename T>
-void check(T value, const std::string &expected) {
+void check(T value, const std::string& expected) {
  DynamicJsonDocument doc(4096);
  doc.to<JsonVariant>().set(value);
  char buffer[256] = "";
--- a/src/ArduinoJson/Array/ArrayFunctions.hpp
+++ b/src/ArduinoJson/Array/ArrayFunctions.hpp
@@ -8,7 +8,7 @@

 namespace ARDUINOJSON_NAMESPACE {

-inline VariantData *arrayAdd(CollectionData *arr, MemoryPool *pool) {
+inline VariantData* arrayAdd(CollectionData* arr, MemoryPool* pool) {
  return arr ? arr->addElement(pool) : 0;
 }

--- a/src/ArduinoJson/Array/ArrayIterator.hpp
+++ b/src/ArduinoJson/Array/ArrayIterator.hpp
@@ -11,13 +11,13 @@ namespace ARDUINOJSON_NAMESPACE {

 class VariantPtr {
 public:
-  VariantPtr(MemoryPool *pool, VariantData *data) : _variant(pool, data) {}
+  VariantPtr(MemoryPool* pool, VariantData* data) : _variant(pool, data) {}

-  VariantRef *operator->() {
+  VariantRef* operator->() {
    return &_variant;
  }

-  VariantRef &operator*() {
+  VariantRef& operator*() {
    return _variant;
  }

@@ -28,7 +28,7 @@ class VariantPtr {
 class ArrayIterator {
 public:
  ArrayIterator() : _slot(0) {}
-  explicit ArrayIterator(MemoryPool *pool, VariantSlot *slot)
+  explicit ArrayIterator(MemoryPool* pool, VariantSlot* slot)
      : _pool(pool), _slot(slot) {}

  VariantRef operator*() const {
@@ -38,42 +38,42 @@ class ArrayIterator {
    return VariantPtr(_pool, _slot->data());
  }

-  bool operator==(const ArrayIterator &other) const {
+  bool operator==(const ArrayIterator& other) const {
    return _slot == other._slot;
  }

-  bool operator!=(const ArrayIterator &other) const {
+  bool operator!=(const ArrayIterator& other) const {
    return _slot != other._slot;
  }

-  ArrayIterator &operator++() {
+  ArrayIterator& operator++() {
    _slot = _slot->next();
    return *this;
  }

-  ArrayIterator &operator+=(size_t distance) {
+  ArrayIterator& operator+=(size_t distance) {
    _slot = _slot->next(distance);
    return *this;
  }

-  VariantSlot *internal() {
+  VariantSlot* internal() {
    return _slot;
  }

 private:
-  MemoryPool *_pool;
-  VariantSlot *_slot;
+  MemoryPool* _pool;
+  VariantSlot* _slot;
 };

 class VariantConstPtr {
 public:
-  VariantConstPtr(const VariantData *data) : _variant(data) {}
+  VariantConstPtr(const VariantData* data) : _variant(data) {}

-  VariantConstRef *operator->() {
+  VariantConstRef* operator->() {
    return &_variant;
  }

-  VariantConstRef &operator*() {
+  VariantConstRef& operator*() {
    return _variant;
  }

@@ -84,7 +84,7 @@ class VariantConstPtr {
 class ArrayConstRefIterator {
 public:
  ArrayConstRefIterator() : _slot(0) {}
-  explicit ArrayConstRefIterator(const VariantSlot *slot) : _slot(slot) {}
+  explicit ArrayConstRefIterator(const VariantSlot* slot) : _slot(slot) {}

  VariantConstRef operator*() const {
    return VariantConstRef(_slot->data());
@@ -93,29 +93,29 @@ class ArrayConstRefIterator {
    return VariantConstPtr(_slot->data());
  }

-  bool operator==(const ArrayConstRefIterator &other) const {
+  bool operator==(const ArrayConstRefIterator& other) const {
    return _slot == other._slot;
  }

-  bool operator!=(const ArrayConstRefIterator &other) const {
+  bool operator!=(const ArrayConstRefIterator& other) const {
    return _slot != other._slot;
  }

-  ArrayConstRefIterator &operator++() {
+  ArrayConstRefIterator& operator++() {
    _slot = _slot->next();
    return *this;
  }

-  ArrayConstRefIterator &operator+=(size_t distance) {
+  ArrayConstRefIterator& operator+=(size_t distance) {
    _slot = _slot->next(distance);
    return *this;
  }

-  const VariantSlot *internal() {
+  const VariantSlot* internal() {
    return _slot;
  }

 private:
-  const VariantSlot *_slot;
+  const VariantSlot* _slot;
 };
 }  // namespace ARDUINOJSON_NAMESPACE
--- a/src/ArduinoJson/Array/ArrayShortcuts.hpp
+++ b/src/ArduinoJson/Array/ArrayShortcuts.hpp
@@ -30,20 +30,20 @@ class ArrayShortcuts {
  // TValue = bool, long, int, short, float, double, serialized, VariantRef,
  //          std::string, String, ObjectRef
  template <typename T>
-  FORCE_INLINE bool add(const T &value) const {
+  FORCE_INLINE bool add(const T& value) const {
    return impl()->add().set(value);
  }
  //
  // bool add(TValue);
  // TValue = char*, const char*, const __FlashStringHelper*
  template <typename T>
-  FORCE_INLINE bool add(T *value) const {
+  FORCE_INLINE bool add(T* value) const {
    return impl()->add().set(value);
  }

 private:
-  const TArray *impl() const {
-    return static_cast<const TArray *>(this);
+  const TArray* impl() const {
+    return static_cast<const TArray*>(this);
  }
 };
 }  // namespace ARDUINOJSON_NAMESPACE
--- a/src/ArduinoJson/Collection/CollectionData.hpp
+++ b/src/ArduinoJson/Collection/CollectionData.hpp
@@ -16,8 +16,8 @@ class VariantData;
 class VariantSlot;

 class CollectionData {
-  VariantSlot *_head;
-  VariantSlot *_tail;
+  VariantSlot* _head;
+  VariantSlot* _tail;

 public:
  // Must be a POD!
@@ -28,24 +28,24 @@ class CollectionData {

  // Array only

-  VariantData *addElement(MemoryPool *pool);
+  VariantData* addElement(MemoryPool* pool);

-  VariantData *getElement(size_t index) const;
+  VariantData* getElement(size_t index) const;

-  VariantData *getOrAddElement(size_t index, MemoryPool *pool);
+  VariantData* getOrAddElement(size_t index, MemoryPool* pool);

  void removeElement(size_t index);

  // Object only

  template <typename TAdaptedString, typename TStoragePolicy>
-  VariantData *addMember(TAdaptedString key, MemoryPool *pool, TStoragePolicy);
+  VariantData* addMember(TAdaptedString key, MemoryPool* pool, TStoragePolicy);

  template <typename TAdaptedString>
-  VariantData *getMember(TAdaptedString key) const;
+  VariantData* getMember(TAdaptedString key) const;

  template <typename TAdaptedString, typename TStoragePolicy>
-  VariantData *getOrAddMember(TAdaptedString key, MemoryPool *pool,
+  VariantData* getOrAddMember(TAdaptedString key, MemoryPool* pool,
                              TStoragePolicy);

  template <typename TAdaptedString>
@@ -54,7 +54,7 @@ class CollectionData {
  }

  template <typename TAdaptedString>
-  bool containsKey(const TAdaptedString &key) const;
+  bool containsKey(const TAdaptedString& key) const;

  // Generic

@@ -62,34 +62,34 @@ class CollectionData {
  size_t memoryUsage() const;
  size_t size() const;

-  VariantSlot *addSlot(MemoryPool *);
-  void removeSlot(VariantSlot *slot);
+  VariantSlot* addSlot(MemoryPool*);
+  void removeSlot(VariantSlot* slot);

-  bool copyFrom(const CollectionData &src, MemoryPool *pool);
+  bool copyFrom(const CollectionData& src, MemoryPool* pool);

-  VariantSlot *head() const {
+  VariantSlot* head() const {
    return _head;
  }

  void movePointers(ptrdiff_t stringDistance, ptrdiff_t variantDistance);

 private:
-  VariantSlot *getSlot(size_t index) const;
+  VariantSlot* getSlot(size_t index) const;

  template <typename TAdaptedString>
-  VariantSlot *getSlot(TAdaptedString key) const;
+  VariantSlot* getSlot(TAdaptedString key) const;

-  VariantSlot *getPreviousSlot(VariantSlot *) const;
+  VariantSlot* getPreviousSlot(VariantSlot*) const;
 };

-inline const VariantData *collectionToVariant(
-    const CollectionData *collection) {
-  const void *data = collection;  // prevent warning cast-align
-  return reinterpret_cast<const VariantData *>(data);
+inline const VariantData* collectionToVariant(
+    const CollectionData* collection) {
+  const void* data = collection;  // prevent warning cast-align
+  return reinterpret_cast<const VariantData*>(data);
 }

-inline VariantData *collectionToVariant(CollectionData *collection) {
-  void *data = collection;  // prevent warning cast-align
-  return reinterpret_cast<VariantData *>(data);
+inline VariantData* collectionToVariant(CollectionData* collection) {
+  void* data = collection;  // prevent warning cast-align
+  return reinterpret_cast<VariantData*>(data);
 }
 }  // namespace ARDUINOJSON_NAMESPACE
--- a/src/ArduinoJson/Deserialization/deserialize.hpp
+++ b/src/ArduinoJson/Deserialization/deserialize.hpp
@@ -14,7 +14,7 @@ namespace ARDUINOJSON_NAMESPACE {

 template <template <typename, typename> class TDeserializer, typename TReader,
          typename TWriter>
-TDeserializer<TReader, TWriter> makeDeserializer(MemoryPool *pool,
+TDeserializer<TReader, TWriter> makeDeserializer(MemoryPool* pool,
                                                 TReader reader,
                                                 TWriter writer) {
  ARDUINOJSON_ASSERT(pool != 0);
@@ -29,11 +29,11 @@ TDeserializer<TReader, TWriter> makeDeserializer(MemoryPool *pool,
 template <template <typename, typename> class TDeserializer, typename TString,
          typename TFilter>
 typename enable_if<!is_array<TString>::value, DeserializationError>::type
-deserialize(JsonDocument &doc, const TString &input, NestingLimit nestingLimit,
+deserialize(JsonDocument& doc, const TString& input, NestingLimit nestingLimit,
            TFilter filter) {
  Reader<TString> reader(input);
-  VariantData *data = VariantAttorney::getData(doc);
-  MemoryPool *pool = VariantAttorney::getPool(doc);
+  VariantData* data = VariantAttorney::getData(doc);
+  MemoryPool* pool = VariantAttorney::getPool(doc);
  doc.clear();
  return makeDeserializer<TDeserializer>(pool, reader,
                                         makeStringStorage(input, pool))
@@ -45,12 +45,12 @@ deserialize(JsonDocument &doc, const TString &input, NestingLimit nestingLimit,
 // deserialize(JsonDocument&, const __FlashStringHelper*, size_t, NL, Filter);
 template <template <typename, typename> class TDeserializer, typename TChar,
          typename TFilter>
-DeserializationError deserialize(JsonDocument &doc, TChar *input,
+DeserializationError deserialize(JsonDocument& doc, TChar* input,
                                 size_t inputSize, NestingLimit nestingLimit,
                                 TFilter filter) {
-  BoundedReader<TChar *> reader(input, inputSize);
-  VariantData *data = VariantAttorney::getData(doc);
-  MemoryPool *pool = VariantAttorney::getPool(doc);
+  BoundedReader<TChar*> reader(input, inputSize);
+  VariantData* data = VariantAttorney::getData(doc);
+  MemoryPool* pool = VariantAttorney::getPool(doc);
  doc.clear();
  return makeDeserializer<TDeserializer>(pool, reader,
                                         makeStringStorage(input, pool))
@@ -61,11 +61,11 @@ DeserializationError deserialize(JsonDocument &doc, TChar *input,
 // deserialize(JsonDocument&, Stream&, NestingLimit, Filter);
 template <template <typename, typename> class TDeserializer, typename TStream,
          typename TFilter>
-DeserializationError deserialize(JsonDocument &doc, TStream &input,
+DeserializationError deserialize(JsonDocument& doc, TStream& input,
                                 NestingLimit nestingLimit, TFilter filter) {
  Reader<TStream> reader(input);
-  VariantData *data = VariantAttorney::getData(doc);
-  MemoryPool *pool = VariantAttorney::getPool(doc);
+  VariantData* data = VariantAttorney::getData(doc);
+  MemoryPool* pool = VariantAttorney::getPool(doc);
  doc.clear();
  return makeDeserializer<TDeserializer>(pool, reader,
                                         makeStringStorage(input, pool))
--- a/src/ArduinoJson/Json/EscapeSequence.hpp
+++ b/src/ArduinoJson/Json/EscapeSequence.hpp
@@ -12,7 +12,7 @@ class EscapeSequence {
 public:
  // Optimized for code size on a 8-bit AVR
  static char escapeChar(char c) {
-    const char *p = escapeTable(true);
+    const char* p = escapeTable(true);
    while (p[0] && p[1] != c) {
      p += 2;
    }
@@ -21,7 +21,7 @@ class EscapeSequence {

  // Optimized for code size on a 8-bit AVR
  static char unescapeChar(char c) {
-    const char *p = escapeTable(false);
+    const char* p = escapeTable(false);
    for (;;) {
      if (p[0] == '\0')
        return 0;
@@ -32,7 +32,7 @@ class EscapeSequence {
  }

 private:
-  static const char *escapeTable(bool excludeSolidus) {
+  static const char* escapeTable(bool excludeSolidus) {
    return &"//\"\"\\\\b\bf\fn\nr\rt\t"[excludeSolidus ? 2 : 0];
  }
 };
--- a/src/ArduinoJson/Json/JsonDeserializer.hpp
+++ b/src/ArduinoJson/Json/JsonDeserializer.hpp
@@ -20,7 +20,7 @@ namespace ARDUINOJSON_NAMESPACE {
 template <typename TReader, typename TStringStorage>
 class JsonDeserializer {
 public:
-  JsonDeserializer(MemoryPool *pool, TReader reader,
+  JsonDeserializer(MemoryPool* pool, TReader reader,
                   TStringStorage stringStorage)
      : _stringStorage(stringStorage),
        _foundSomething(false),
@@ -28,7 +28,7 @@ class JsonDeserializer {
        _pool(pool) {}

  template <typename TFilter>
-  DeserializationError parse(VariantData &variant, TFilter filter,
+  DeserializationError parse(VariantData& variant, TFilter filter,
                             NestingLimit nestingLimit) {
    DeserializationError::Code err;

@@ -59,7 +59,7 @@ class JsonDeserializer {
  }

  template <typename TFilter>
-  DeserializationError::Code parseVariant(VariantData &variant, TFilter filter,
+  DeserializationError::Code parseVariant(VariantData& variant, TFilter filter,
                                          NestingLimit nestingLimit) {
    DeserializationError::Code err;

@@ -143,7 +143,7 @@ class JsonDeserializer {
  }

  template <typename TFilter>
-  DeserializationError::Code parseArray(CollectionData &array, TFilter filter,
+  DeserializationError::Code parseArray(CollectionData& array, TFilter filter,
                                        NestingLimit nestingLimit) {
    DeserializationError::Code err;

@@ -169,7 +169,7 @@ class JsonDeserializer {
    for (;;) {
      if (memberFilter.allow()) {
        // Allocate slot in array
-        VariantData *value = array.addElement(_pool);
+        VariantData* value = array.addElement(_pool);
        if (!value)
          return DeserializationError::NoMemory;

@@ -227,7 +227,7 @@ class JsonDeserializer {
  }

  template <typename TFilter>
-  DeserializationError::Code parseObject(CollectionData &object, TFilter filter,
+  DeserializationError::Code parseObject(CollectionData& object, TFilter filter,
                                         NestingLimit nestingLimit) {
    DeserializationError::Code err;

@@ -268,14 +268,14 @@ class JsonDeserializer {
      TFilter memberFilter = filter[key.c_str()];

      if (memberFilter.allow()) {
-        VariantData *variant = object.getMember(adaptString(key.c_str()));
+        VariantData* variant = object.getMember(adaptString(key.c_str()));
        if (!variant) {
          // Save key in memory pool.
          // This MUST be done before adding the slot.
          key = _stringStorage.save();

          // Allocate slot in object
-          VariantSlot *slot = object.addSlot(_pool);
+          VariantSlot* slot = object.addSlot(_pool);
          if (!slot)
            return DeserializationError::NoMemory;

@@ -378,7 +378,7 @@ class JsonDeserializer {
    }
  }

-  DeserializationError::Code parseStringValue(VariantData &variant) {
+  DeserializationError::Code parseStringValue(VariantData& variant) {
    DeserializationError::Code err;

    _stringStorage.startString();
@@ -503,7 +503,7 @@ class JsonDeserializer {
    return DeserializationError::Ok;
  }

-  DeserializationError::Code parseNumericValue(VariantData &result) {
+  DeserializationError::Code parseNumericValue(VariantData& result) {
    uint8_t n = 0;

    char c = current();
@@ -529,7 +529,7 @@ class JsonDeserializer {
    return DeserializationError::Ok;
  }

-  DeserializationError::Code parseHex4(uint16_t &result) {
+  DeserializationError::Code parseHex4(uint16_t& result) {
    result = 0;
    for (uint8_t i = 0; i < 4; ++i) {
      char digit = current();
@@ -639,7 +639,7 @@ class JsonDeserializer {
    }
  }

-  DeserializationError::Code skipKeyword(const char *s) {
+  DeserializationError::Code skipKeyword(const char* s) {
    while (*s) {
      char c = current();
      if (c == '\0')
@@ -655,7 +655,7 @@ class JsonDeserializer {
  TStringStorage _stringStorage;
  bool _foundSomething;
  Latch<TReader> _latch;
-  MemoryPool *_pool;
+  MemoryPool* _pool;
  char _buffer[64];  // using a member instead of a local variable because it
                     // ended in the recursive path after compiler inlined the
                     // code
@@ -667,7 +667,7 @@ class JsonDeserializer {
 // ... = NestingLimit
 template <typename TString>
 DeserializationError deserializeJson(
-    JsonDocument &doc, const TString &input,
+    JsonDocument& doc, const TString& input,
    NestingLimit nestingLimit = NestingLimit()) {
  return deserialize<JsonDeserializer>(doc, input, nestingLimit,
                                       AllowAllFilter());
@@ -675,13 +675,13 @@ DeserializationError deserializeJson(
 // ... = Filter, NestingLimit
 template <typename TString>
 DeserializationError deserializeJson(
-    JsonDocument &doc, const TString &input, Filter filter,
+    JsonDocument& doc, const TString& input, Filter filter,
    NestingLimit nestingLimit = NestingLimit()) {
  return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
 }
 // ... = NestingLimit, Filter
 template <typename TString>
-DeserializationError deserializeJson(JsonDocument &doc, const TString &input,
+DeserializationError deserializeJson(JsonDocument& doc, const TString& input,
                                     NestingLimit nestingLimit, Filter filter) {
  return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
 }
@@ -692,7 +692,7 @@ DeserializationError deserializeJson(JsonDocument &doc, const TString &input,
 // ... = NestingLimit
 template <typename TStream>
 DeserializationError deserializeJson(
-    JsonDocument &doc, TStream &input,
+    JsonDocument& doc, TStream& input,
    NestingLimit nestingLimit = NestingLimit()) {
  return deserialize<JsonDeserializer>(doc, input, nestingLimit,
                                       AllowAllFilter());
@@ -700,13 +700,13 @@ DeserializationError deserializeJson(
 // ... = Filter, NestingLimit
 template <typename TStream>
 DeserializationError deserializeJson(
-    JsonDocument &doc, TStream &input, Filter filter,
+    JsonDocument& doc, TStream& input, Filter filter,
    NestingLimit nestingLimit = NestingLimit()) {
  return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
 }
 // ... = NestingLimit, Filter
 template <typename TStream>
-DeserializationError deserializeJson(JsonDocument &doc, TStream &input,
+DeserializationError deserializeJson(JsonDocument& doc, TStream& input,
                                     NestingLimit nestingLimit, Filter filter) {
  return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
 }
@@ -717,7 +717,7 @@ DeserializationError deserializeJson(JsonDocument &doc, TStream &input,
 // ... = NestingLimit
 template <typename TChar>
 DeserializationError deserializeJson(
-    JsonDocument &doc, TChar *input,
+    JsonDocument& doc, TChar* input,
    NestingLimit nestingLimit = NestingLimit()) {
  return deserialize<JsonDeserializer>(doc, input, nestingLimit,
                                       AllowAllFilter());
@@ -725,13 +725,13 @@ DeserializationError deserializeJson(
 // ... = Filter, NestingLimit
 template <typename TChar>
 DeserializationError deserializeJson(
-    JsonDocument &doc, TChar *input, Filter filter,
+    JsonDocument& doc, TChar* input, Filter filter,
    NestingLimit nestingLimit = NestingLimit()) {
  return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
 }
 // ... = NestingLimit, Filter
 template <typename TChar>
-DeserializationError deserializeJson(JsonDocument &doc, TChar *input,
+DeserializationError deserializeJson(JsonDocument& doc, TChar* input,
                                     NestingLimit nestingLimit, Filter filter) {
  return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
 }
@@ -742,7 +742,7 @@ DeserializationError deserializeJson(JsonDocument &doc, TChar *input,
 // ... = NestingLimit
 template <typename TChar>
 DeserializationError deserializeJson(
-    JsonDocument &doc, TChar *input, size_t inputSize,
+    JsonDocument& doc, TChar* input, size_t inputSize,
    NestingLimit nestingLimit = NestingLimit()) {
  return deserialize<JsonDeserializer>(doc, input, inputSize, nestingLimit,
                                       AllowAllFilter());
@@ -750,14 +750,14 @@ DeserializationError deserializeJson(
 // ... = Filter, NestingLimit
 template <typename TChar>
 DeserializationError deserializeJson(
-    JsonDocument &doc, TChar *input, size_t inputSize, Filter filter,
+    JsonDocument& doc, TChar* input, size_t inputSize, Filter filter,
    NestingLimit nestingLimit = NestingLimit()) {
  return deserialize<JsonDeserializer>(doc, input, inputSize, nestingLimit,
                                       filter);
 }
 // ... = NestingLimit, Filter
 template <typename TChar>
-DeserializationError deserializeJson(JsonDocument &doc, TChar *input,
+DeserializationError deserializeJson(JsonDocument& doc, TChar* input,
                                     size_t inputSize,
                                     NestingLimit nestingLimit, Filter filter) {
  return deserialize<JsonDeserializer>(doc, input, inputSize, nestingLimit,
--- a/src/ArduinoJson/Json/JsonSerializer.hpp
+++ b/src/ArduinoJson/Json/JsonSerializer.hpp
@@ -18,10 +18,10 @@ class JsonSerializer : public Visitor<size_t> {

  JsonSerializer(TWriter writer) : _formatter(writer) {}

-  FORCE_INLINE size_t visitArray(const CollectionData &array) {
+  FORCE_INLINE size_t visitArray(const CollectionData& array) {
    write('[');

-    const VariantSlot *slot = array.head();
+    const VariantSlot* slot = array.head();

    while (slot != 0) {
      slot->data()->accept(*this);
@@ -37,10 +37,10 @@ class JsonSerializer : public Visitor<size_t> {
    return bytesWritten();
  }

-  size_t visitObject(const CollectionData &object) {
+  size_t visitObject(const CollectionData& object) {
    write('{');

-    const VariantSlot *slot = object.head();
+    const VariantSlot* slot = object.head();

    while (slot != 0) {
      _formatter.writeString(slot->key());
@@ -63,17 +63,17 @@ class JsonSerializer : public Visitor<size_t> {
    return bytesWritten();
  }

-  size_t visitString(const char *value) {
+  size_t visitString(const char* value) {
    _formatter.writeString(value);
    return bytesWritten();
  }

-  size_t visitString(const char *value, size_t n) {
+  size_t visitString(const char* value, size_t n) {
    _formatter.writeString(value, n);
    return bytesWritten();
  }

-  size_t visitRawJson(const char *data, size_t n) {
+  size_t visitRawJson(const char* data, size_t n) {
    _formatter.writeRaw(data, n);
    return bytesWritten();
  }
@@ -107,7 +107,7 @@ class JsonSerializer : public Visitor<size_t> {
    _formatter.writeRaw(c);
  }

-  void write(const char *s) {
+  void write(const char* s) {
    _formatter.writeRaw(s);
  }

@@ -116,11 +116,11 @@ class JsonSerializer : public Visitor<size_t> {
 };

 template <typename TDestination>
-size_t serializeJson(VariantConstRef source, TDestination &destination) {
+size_t serializeJson(VariantConstRef source, TDestination& destination) {
  return serialize<JsonSerializer>(source, destination);
 }

-inline size_t serializeJson(VariantConstRef source, void *buffer,
+inline size_t serializeJson(VariantConstRef source, void* buffer,
                            size_t bufferSize) {
  return serialize<JsonSerializer>(source, buffer, bufferSize);
 }
@@ -132,8 +132,8 @@ inline size_t measureJson(VariantConstRef source) {
 #if ARDUINOJSON_ENABLE_STD_STREAM
 template <typename T>
 inline typename enable_if<is_convertible<T, VariantConstRef>::value,
-                          std::ostream &>::type
-operator<<(std::ostream &os, const T &source) {
+                          std::ostream&>::type
+operator<<(std::ostream& os, const T& source) {
  serializeJson(source, os);
  return os;
 }
--- a/src/ArduinoJson/Json/PrettyJsonSerializer.hpp
+++ b/src/ArduinoJson/Json/PrettyJsonSerializer.hpp
@@ -18,8 +18,8 @@ class PrettyJsonSerializer : public JsonSerializer<TWriter> {
 public:
  PrettyJsonSerializer(TWriter writer) : base(writer), _nesting(0) {}

-  size_t visitArray(const CollectionData &array) {
-    const VariantSlot *slot = array.head();
+  size_t visitArray(const CollectionData& array) {
+    const VariantSlot* slot = array.head();
    if (slot) {
      base::write("[\r\n");
      _nesting++;
@@ -39,8 +39,8 @@ class PrettyJsonSerializer : public JsonSerializer<TWriter> {
    return this->bytesWritten();
  }

-  size_t visitObject(const CollectionData &object) {
-    const VariantSlot *slot = object.head();
+  size_t visitObject(const CollectionData& object) {
+    const VariantSlot* slot = object.head();
    if (slot) {
      base::write("{\r\n");
      _nesting++;
@@ -71,11 +71,11 @@ class PrettyJsonSerializer : public JsonSerializer<TWriter> {
 };

 template <typename TDestination>
-size_t serializeJsonPretty(VariantConstRef source, TDestination &destination) {
+size_t serializeJsonPretty(VariantConstRef source, TDestination& destination) {
  return serialize<PrettyJsonSerializer>(source, destination);
 }

-inline size_t serializeJsonPretty(VariantConstRef source, void *buffer,
+inline size_t serializeJsonPretty(VariantConstRef source, void* buffer,
                                  size_t bufferSize) {
  return serialize<PrettyJsonSerializer>(source, buffer, bufferSize);
 }
--- a/src/ArduinoJson/Json/TextFormatter.hpp
+++ b/src/ArduinoJson/Json/TextFormatter.hpp
@@ -34,14 +34,14 @@ class TextFormatter {
      writeRaw("false");
  }

-  void writeString(const char *value) {
+  void writeString(const char* value) {
    ARDUINOJSON_ASSERT(value != NULL);
    writeRaw('\"');
    while (*value) writeChar(*value++);
    writeRaw('\"');
  }

-  void writeString(const char *value, size_t n) {
+  void writeString(const char* value, size_t n) {
    ARDUINOJSON_ASSERT(value != NULL);
    writeRaw('\"');
    while (n--) writeChar(*value++);
@@ -111,8 +111,8 @@ class TextFormatter {
  template <typename T>
  typename enable_if<is_unsigned<T>::value>::type writeInteger(T value) {
    char buffer[22];
-    char *end = buffer + sizeof(buffer);
-    char *begin = end;
+    char* end = buffer + sizeof(buffer);
+    char* begin = end;

    // write the string in reverse order
    do {
@@ -127,8 +127,8 @@ class TextFormatter {
  void writeDecimals(uint32_t value, int8_t width) {
    // buffer should be big enough for all digits and the dot
    char buffer[16];
-    char *end = buffer + sizeof(buffer);
-    char *begin = end;
+    char* end = buffer + sizeof(buffer);
+    char* begin = end;

    // write the string in reverse order
    while (width--) {
@@ -141,22 +141,22 @@ class TextFormatter {
    writeRaw(begin, end);
  }

-  void writeRaw(const char *s) {
-    _writer.write(reinterpret_cast<const uint8_t *>(s), strlen(s));
+  void writeRaw(const char* s) {
+    _writer.write(reinterpret_cast<const uint8_t*>(s), strlen(s));
  }

-  void writeRaw(const char *s, size_t n) {
-    _writer.write(reinterpret_cast<const uint8_t *>(s), n);
+  void writeRaw(const char* s, size_t n) {
+    _writer.write(reinterpret_cast<const uint8_t*>(s), n);
  }

-  void writeRaw(const char *begin, const char *end) {
-    _writer.write(reinterpret_cast<const uint8_t *>(begin),
+  void writeRaw(const char* begin, const char* end) {
+    _writer.write(reinterpret_cast<const uint8_t*>(begin),
                  static_cast<size_t>(end - begin));
  }

  template <size_t N>
  void writeRaw(const char (&s)[N]) {
-    _writer.write(reinterpret_cast<const uint8_t *>(s), N - 1);
+    _writer.write(reinterpret_cast<const uint8_t*>(s), N - 1);
  }
  void writeRaw(char c) {
    _writer.write(static_cast<uint8_t>(c));
@@ -166,6 +166,6 @@ class TextFormatter {
  CountingDecorator<TWriter> _writer;

 private:
-  TextFormatter &operator=(const TextFormatter &);  // cannot be assigned
+  TextFormatter& operator=(const TextFormatter&);  // cannot be assigned
 };
 }  // namespace ARDUINOJSON_NAMESPACE
--- a/src/ArduinoJson/Memory/Alignment.hpp
+++ b/src/ArduinoJson/Memory/Alignment.hpp
@@ -13,19 +13,19 @@ namespace ARDUINOJSON_NAMESPACE {
 #if ARDUINOJSON_ENABLE_ALIGNMENT

 inline bool isAligned(size_t value) {
-  const size_t mask = sizeof(void *) - 1;
+  const size_t mask = sizeof(void*) - 1;
  size_t addr = value;
  return (addr & mask) == 0;
 }

 inline size_t addPadding(size_t bytes) {
-  const size_t mask = sizeof(void *) - 1;
+  const size_t mask = sizeof(void*) - 1;
  return (bytes + mask) & ~mask;
 }

 template <size_t bytes>
 struct AddPadding {
-  static const size_t mask = sizeof(void *) - 1;
+  static const size_t mask = sizeof(void*) - 1;
  static const size_t value = (bytes + mask) & ~mask;
 };

@@ -47,14 +47,14 @@ struct AddPadding {
 #endif

 template <typename T>
-inline bool isAligned(T *ptr) {
+inline bool isAligned(T* ptr) {
  return isAligned(reinterpret_cast<size_t>(ptr));
 }

 template <typename T>
-inline T *addPadding(T *p) {
+inline T* addPadding(T* p) {
  size_t address = addPadding(reinterpret_cast<size_t>(p));
-  return reinterpret_cast<T *>(address);
+  return reinterpret_cast<T*>(address);
 }

 }  // namespace ARDUINOJSON_NAMESPACE
--- a/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp
+++ b/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp
@@ -16,7 +16,7 @@ namespace ARDUINOJSON_NAMESPACE {
 template <typename TReader, typename TStringStorage>
 class MsgPackDeserializer {
 public:
-  MsgPackDeserializer(MemoryPool *pool, TReader reader,
+  MsgPackDeserializer(MemoryPool* pool, TReader reader,
                      TStringStorage stringStorage)
      : _pool(pool),
        _reader(reader),
@@ -24,7 +24,7 @@ class MsgPackDeserializer {
        _foundSomething(false) {}

  template <typename TFilter>
-  DeserializationError parse(VariantData &variant, TFilter filter,
+  DeserializationError parse(VariantData& variant, TFilter filter,
                             NestingLimit nestingLimit) {
    DeserializationError::Code err;
    err = parseVariant(&variant, filter, nestingLimit);
@@ -33,7 +33,7 @@ class MsgPackDeserializer {

 private:
  template <typename TFilter>
-  DeserializationError::Code parseVariant(VariantData *variant, TFilter filter,
+  DeserializationError::Code parseVariant(VariantData* variant, TFilter filter,
                                          NestingLimit nestingLimit) {
    DeserializationError::Code err;

@@ -222,7 +222,7 @@ class MsgPackDeserializer {
    return DeserializationError::Ok;
  }

-  DeserializationError::Code readByte(uint8_t &value) {
+  DeserializationError::Code readByte(uint8_t& value) {
    int c = _reader.read();
    if (c < 0)
      return DeserializationError::IncompleteInput;
@@ -230,15 +230,15 @@ class MsgPackDeserializer {
    return DeserializationError::Ok;
  }

-  DeserializationError::Code readBytes(uint8_t *p, size_t n) {
-    if (_reader.readBytes(reinterpret_cast<char *>(p), n) == n)
+  DeserializationError::Code readBytes(uint8_t* p, size_t n) {
+    if (_reader.readBytes(reinterpret_cast<char*>(p), n) == n)
      return DeserializationError::Ok;
    return DeserializationError::IncompleteInput;
  }

  template <typename T>
-  DeserializationError::Code readBytes(T &value) {
-    return readBytes(reinterpret_cast<uint8_t *>(&value), sizeof(value));
+  DeserializationError::Code readBytes(T& value) {
+    return readBytes(reinterpret_cast<uint8_t*>(&value), sizeof(value));
  }

  DeserializationError::Code skipBytes(size_t n) {
@@ -250,7 +250,7 @@ class MsgPackDeserializer {
  }

  template <typename T>
-  DeserializationError::Code readInteger(T &value) {
+  DeserializationError::Code readInteger(T& value) {
    DeserializationError::Code err;

    err = readBytes(value);
@@ -263,7 +263,7 @@ class MsgPackDeserializer {
  }

  template <typename T>
-  DeserializationError::Code readInteger(VariantData *variant) {
+  DeserializationError::Code readInteger(VariantData* variant) {
    DeserializationError::Code err;
    T value;

@@ -278,7 +278,7 @@ class MsgPackDeserializer {

  template <typename T>
  typename enable_if<sizeof(T) == 4, DeserializationError::Code>::type
-  readFloat(VariantData *variant) {
+  readFloat(VariantData* variant) {
    DeserializationError::Code err;
    T value;

@@ -294,7 +294,7 @@ class MsgPackDeserializer {

  template <typename T>
  typename enable_if<sizeof(T) == 8, DeserializationError::Code>::type
-  readDouble(VariantData *variant) {
+  readDouble(VariantData* variant) {
    DeserializationError::Code err;
    T value;

@@ -310,11 +310,11 @@ class MsgPackDeserializer {

  template <typename T>
  typename enable_if<sizeof(T) == 4, DeserializationError::Code>::type
-  readDouble(VariantData *variant) {
+  readDouble(VariantData* variant) {
    DeserializationError::Code err;
    uint8_t i[8];  // input is 8 bytes
    T value;       // output is 4 bytes
-    uint8_t *o = reinterpret_cast<uint8_t *>(&value);
+    uint8_t* o = reinterpret_cast<uint8_t*>(&value);

    err = readBytes(i, 8);
    if (err)
@@ -328,7 +328,7 @@ class MsgPackDeserializer {
  }

  template <typename T>
-  DeserializationError::Code readString(VariantData *variant) {
+  DeserializationError::Code readString(VariantData* variant) {
    DeserializationError::Code err;
    T size;

@@ -363,7 +363,7 @@ class MsgPackDeserializer {
    return skipBytes(size);
  }

-  DeserializationError::Code readString(VariantData *variant, size_t n) {
+  DeserializationError::Code readString(VariantData* variant, size_t n) {
    DeserializationError::Code err;

    err = readString(n);
@@ -395,7 +395,7 @@ class MsgPackDeserializer {
  }

  template <typename TSize, typename TFilter>
-  DeserializationError::Code readArray(VariantData *variant, TFilter filter,
+  DeserializationError::Code readArray(VariantData* variant, TFilter filter,
                                       NestingLimit nestingLimit) {
    DeserializationError::Code err;
    TSize size;
@@ -408,7 +408,7 @@ class MsgPackDeserializer {
  }

  template <typename TFilter>
-  DeserializationError::Code readArray(VariantData *variant, size_t n,
+  DeserializationError::Code readArray(VariantData* variant, size_t n,
                                       TFilter filter,
                                       NestingLimit nestingLimit) {
    DeserializationError::Code err;
@@ -418,12 +418,12 @@ class MsgPackDeserializer {

    bool allowArray = filter.allowArray();

-    CollectionData *array = allowArray ? &variant->toArray() : 0;
+    CollectionData* array = allowArray ? &variant->toArray() : 0;

    TFilter memberFilter = filter[0U];

    for (; n; --n) {
-      VariantData *value;
+      VariantData* value;

      if (memberFilter.allow()) {
        value = array->addElement(_pool);
@@ -442,7 +442,7 @@ class MsgPackDeserializer {
  }

  template <typename TSize, typename TFilter>
-  DeserializationError::Code readObject(VariantData *variant, TFilter filter,
+  DeserializationError::Code readObject(VariantData* variant, TFilter filter,
                                        NestingLimit nestingLimit) {
    DeserializationError::Code err;
    TSize size;
@@ -455,7 +455,7 @@ class MsgPackDeserializer {
  }

  template <typename TFilter>
-  DeserializationError::Code readObject(VariantData *variant, size_t n,
+  DeserializationError::Code readObject(VariantData* variant, size_t n,
                                        TFilter filter,
                                        NestingLimit nestingLimit) {
    DeserializationError::Code err;
@@ -463,7 +463,7 @@ class MsgPackDeserializer {
    if (nestingLimit.reached())
      return DeserializationError::TooDeep;

-    CollectionData *object = filter.allowObject() ? &variant->toObject() : 0;
+    CollectionData* object = filter.allowObject() ? &variant->toObject() : 0;

    for (; n; --n) {
      err = readKey();
@@ -472,7 +472,7 @@ class MsgPackDeserializer {

      String key = _stringStorage.str();
      TFilter memberFilter = filter[key.c_str()];
-      VariantData *member;
+      VariantData* member;

      if (memberFilter.allow()) {
        ARDUINOJSON_ASSERT(object);
@@ -481,7 +481,7 @@ class MsgPackDeserializer {
        // This MUST be done before adding the slot.
        key = _stringStorage.save();

-        VariantSlot *slot = object->addSlot(_pool);
+        VariantSlot* slot = object->addSlot(_pool);
        if (!slot)
          return DeserializationError::NoMemory;

@@ -538,7 +538,7 @@ class MsgPackDeserializer {
    return skipBytes(size + 1U);
  }

-  MemoryPool *_pool;
+  MemoryPool* _pool;
  TReader _reader;
  TStringStorage _stringStorage;
  bool _foundSomething;
@@ -550,7 +550,7 @@ class MsgPackDeserializer {
 // ... = NestingLimit
 template <typename TString>
 DeserializationError deserializeMsgPack(
-    JsonDocument &doc, const TString &input,
+    JsonDocument& doc, const TString& input,
    NestingLimit nestingLimit = NestingLimit()) {
  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit,
                                          AllowAllFilter());
@@ -558,13 +558,13 @@ DeserializationError deserializeMsgPack(
 // ... = Filter, NestingLimit
 template <typename TString>
 DeserializationError deserializeMsgPack(
-    JsonDocument &doc, const TString &input, Filter filter,
+    JsonDocument& doc, const TString& input, Filter filter,
    NestingLimit nestingLimit = NestingLimit()) {
  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
 }
 // ... = NestingLimit, Filter
 template <typename TString>
-DeserializationError deserializeMsgPack(JsonDocument &doc, const TString &input,
+DeserializationError deserializeMsgPack(JsonDocument& doc, const TString& input,
                                        NestingLimit nestingLimit,
                                        Filter filter) {
  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
@@ -576,7 +576,7 @@ DeserializationError deserializeMsgPack(JsonDocument &doc, const TString &input,
 // ... = NestingLimit
 template <typename TStream>
 DeserializationError deserializeMsgPack(
-    JsonDocument &doc, TStream &input,
+    JsonDocument& doc, TStream& input,
    NestingLimit nestingLimit = NestingLimit()) {
  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit,
                                          AllowAllFilter());
@@ -584,13 +584,13 @@ DeserializationError deserializeMsgPack(
 // ... = Filter, NestingLimit
 template <typename TStream>
 DeserializationError deserializeMsgPack(
-    JsonDocument &doc, TStream &input, Filter filter,
+    JsonDocument& doc, TStream& input, Filter filter,
    NestingLimit nestingLimit = NestingLimit()) {
  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
 }
 // ... = NestingLimit, Filter
 template <typename TStream>
-DeserializationError deserializeMsgPack(JsonDocument &doc, TStream &input,
+DeserializationError deserializeMsgPack(JsonDocument& doc, TStream& input,
                                        NestingLimit nestingLimit,
                                        Filter filter) {
  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
@@ -602,7 +602,7 @@ DeserializationError deserializeMsgPack(JsonDocument &doc, TStream &input,
 // ... = NestingLimit
 template <typename TChar>
 DeserializationError deserializeMsgPack(
-    JsonDocument &doc, TChar *input,
+    JsonDocument& doc, TChar* input,
    NestingLimit nestingLimit = NestingLimit()) {
  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit,
                                          AllowAllFilter());
@@ -610,13 +610,13 @@ DeserializationError deserializeMsgPack(
 // ... = Filter, NestingLimit
 template <typename TChar>
 DeserializationError deserializeMsgPack(
-    JsonDocument &doc, TChar *input, Filter filter,
+    JsonDocument& doc, TChar* input, Filter filter,
    NestingLimit nestingLimit = NestingLimit()) {
  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
 }
 // ... = NestingLimit, Filter
 template <typename TChar>
-DeserializationError deserializeMsgPack(JsonDocument &doc, TChar *input,
+DeserializationError deserializeMsgPack(JsonDocument& doc, TChar* input,
                                        NestingLimit nestingLimit,
                                        Filter filter) {
  return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
@@ -628,7 +628,7 @@ DeserializationError deserializeMsgPack(JsonDocument &doc, TChar *input,
 // ... = NestingLimit
 template <typename TChar>
 DeserializationError deserializeMsgPack(
-    JsonDocument &doc, TChar *input, size_t inputSize,
+    JsonDocument& doc, TChar* input, size_t inputSize,
    NestingLimit nestingLimit = NestingLimit()) {
  return deserialize<MsgPackDeserializer>(doc, input, inputSize, nestingLimit,
                                          AllowAllFilter());
@@ -636,14 +636,14 @@ DeserializationError deserializeMsgPack(
 // ... = Filter, NestingLimit
 template <typename TChar>
 DeserializationError deserializeMsgPack(
-    JsonDocument &doc, TChar *input, size_t inputSize, Filter filter,
+    JsonDocument& doc, TChar* input, size_t inputSize, Filter filter,
    NestingLimit nestingLimit = NestingLimit()) {
  return deserialize<MsgPackDeserializer>(doc, input, inputSize, nestingLimit,
                                          filter);
 }
 // ... = NestingLimit, Filter
 template <typename TChar>
-DeserializationError deserializeMsgPack(JsonDocument &doc, TChar *input,
+DeserializationError deserializeMsgPack(JsonDocument& doc, TChar* input,
                                        size_t inputSize,
                                        NestingLimit nestingLimit,
                                        Filter filter) {
--- a/src/ArduinoJson/MsgPack/endianess.hpp
+++ b/src/ArduinoJson/MsgPack/endianess.hpp
@@ -9,38 +9,38 @@
 namespace ARDUINOJSON_NAMESPACE {

 #if ARDUINOJSON_LITTLE_ENDIAN
-inline void swapBytes(uint8_t &a, uint8_t &b) {
+inline void swapBytes(uint8_t& a, uint8_t& b) {
  uint8_t t(a);
  a = b;
  b = t;
 }

-inline void fixEndianess(uint8_t *p, integral_constant<size_t, 8>) {
+inline void fixEndianess(uint8_t* p, integral_constant<size_t, 8>) {
  swapBytes(p[0], p[7]);
  swapBytes(p[1], p[6]);
  swapBytes(p[2], p[5]);
  swapBytes(p[3], p[4]);
 }

-inline void fixEndianess(uint8_t *p, integral_constant<size_t, 4>) {
+inline void fixEndianess(uint8_t* p, integral_constant<size_t, 4>) {
  swapBytes(p[0], p[3]);
  swapBytes(p[1], p[2]);
 }

-inline void fixEndianess(uint8_t *p, integral_constant<size_t, 2>) {
+inline void fixEndianess(uint8_t* p, integral_constant<size_t, 2>) {
  swapBytes(p[0], p[1]);
 }

-inline void fixEndianess(uint8_t *, integral_constant<size_t, 1>) {}
+inline void fixEndianess(uint8_t*, integral_constant<size_t, 1>) {}

 template <typename T>
-inline void fixEndianess(T &value) {
-  fixEndianess(reinterpret_cast<uint8_t *>(&value),
+inline void fixEndianess(T& value) {
+  fixEndianess(reinterpret_cast<uint8_t*>(&value),
               integral_constant<size_t, sizeof(T)>());
 }
 #else
 template <typename T>
-inline void fixEndianess(T &) {}
+inline void fixEndianess(T&) {}
 #endif

 }  // namespace ARDUINOJSON_NAMESPACE
--- a/src/ArduinoJson/Numbers/arithmeticCompare.hpp
+++ b/src/ArduinoJson/Numbers/arithmeticCompare.hpp
@@ -20,7 +20,7 @@ enum CompareResult {
 };

 template <typename T>
-CompareResult arithmeticCompare(const T &lhs, const T &rhs) {
+CompareResult arithmeticCompare(const T& lhs, const T& rhs) {
  if (lhs < rhs)
    return COMPARE_RESULT_LESS;
  else if (lhs > rhs)
@@ -31,38 +31,38 @@ CompareResult arithmeticCompare(const T &lhs, const T &rhs) {

 template <typename T1, typename T2>
 CompareResult arithmeticCompare(
-    const T1 &lhs, const T2 &rhs,
+    const T1& lhs, const T2& rhs,
    typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
                           sizeof(T1) < sizeof(T2),
                       int  // Using int instead of void to avoid C2572 on
                            // Visual Studio 2012, 2013, and 2015
-                       >::type * = 0) {
+                       >::type* = 0) {
  return arithmeticCompare<T2>(static_cast<T2>(lhs), rhs);
 }

 template <typename T1, typename T2>
 CompareResult arithmeticCompare(
-    const T1 &lhs, const T2 &rhs,
+    const T1& lhs, const T2& rhs,
    typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
-                       sizeof(T2) < sizeof(T1)>::type * = 0) {
+                       sizeof(T2) < sizeof(T1)>::type* = 0) {
  return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs));
 }

 template <typename T1, typename T2>
 CompareResult arithmeticCompare(
-    const T1 &lhs, const T2 &rhs,
+    const T1& lhs, const T2& rhs,
    typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
                       is_signed<T1>::value == is_signed<T2>::value &&
-                       sizeof(T2) == sizeof(T1)>::type * = 0) {
+                       sizeof(T2) == sizeof(T1)>::type* = 0) {
  return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs));
 }

 template <typename T1, typename T2>
 CompareResult arithmeticCompare(
-    const T1 &lhs, const T2 &rhs,
+    const T1& lhs, const T2& rhs,
    typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
                       is_unsigned<T1>::value && is_signed<T2>::value &&
-                       sizeof(T2) == sizeof(T1)>::type * = 0) {
+                       sizeof(T2) == sizeof(T1)>::type* = 0) {
  if (rhs < 0)
    return COMPARE_RESULT_GREATER;
  return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs));
@@ -70,10 +70,10 @@ CompareResult arithmeticCompare(

 template <typename T1, typename T2>
 CompareResult arithmeticCompare(
-    const T1 &lhs, const T2 &rhs,
+    const T1& lhs, const T2& rhs,
    typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
                       is_signed<T1>::value && is_unsigned<T2>::value &&
-                       sizeof(T2) == sizeof(T1)>::type * = 0) {
+                       sizeof(T2) == sizeof(T1)>::type* = 0) {
  if (lhs < 0)
    return COMPARE_RESULT_LESS;
  return arithmeticCompare<T2>(static_cast<T2>(lhs), rhs);
@@ -81,23 +81,23 @@ CompareResult arithmeticCompare(

 template <typename T1, typename T2>
 CompareResult arithmeticCompare(
-    const T1 &lhs, const T2 &rhs,
+    const T1& lhs, const T2& rhs,
    typename enable_if<is_floating_point<T1>::value ||
-                       is_floating_point<T2>::value>::type * = 0) {
+                       is_floating_point<T2>::value>::type* = 0) {
  return arithmeticCompare<double>(static_cast<double>(lhs),
                                   static_cast<double>(rhs));
 }

 template <typename T2>
 CompareResult arithmeticCompareNegateLeft(
-    UInt, const T2 &, typename enable_if<is_unsigned<T2>::value>::type * = 0) {
+    UInt, const T2&, typename enable_if<is_unsigned<T2>::value>::type* = 0) {
  return COMPARE_RESULT_LESS;
 }

 template <typename T2>
 CompareResult arithmeticCompareNegateLeft(
-    UInt lhs, const T2 &rhs,
-    typename enable_if<is_signed<T2>::value>::type * = 0) {
+    UInt lhs, const T2& rhs,
+    typename enable_if<is_signed<T2>::value>::type* = 0) {
  if (rhs > 0)
    return COMPARE_RESULT_LESS;
  return arithmeticCompare(-rhs, static_cast<T2>(lhs));
@@ -105,14 +105,14 @@ CompareResult arithmeticCompareNegateLeft(

 template <typename T1>
 CompareResult arithmeticCompareNegateRight(
-    const T1 &, UInt, typename enable_if<is_unsigned<T1>::value>::type * = 0) {
+    const T1&, UInt, typename enable_if<is_unsigned<T1>::value>::type* = 0) {
  return COMPARE_RESULT_GREATER;
 }

 template <typename T1>
 CompareResult arithmeticCompareNegateRight(
-    const T1 &lhs, UInt rhs,
-    typename enable_if<is_signed<T1>::value>::type * = 0) {
+    const T1& lhs, UInt rhs,
+    typename enable_if<is_signed<T1>::value>::type* = 0) {
  if (lhs > 0)
    return COMPARE_RESULT_GREATER;
  return arithmeticCompare(static_cast<T1>(rhs), -lhs);
--- a/src/ArduinoJson/Object/MemberProxy.hpp
+++ b/src/ArduinoJson/Object/MemberProxy.hpp
@@ -31,21 +31,21 @@ class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >,
  FORCE_INLINE MemberProxy(TObject variant, TStringRef key)
      : _object(variant), _key(key) {}

-  FORCE_INLINE MemberProxy(const MemberProxy &src)
+  FORCE_INLINE MemberProxy(const MemberProxy& src)
      : _object(src._object), _key(src._key) {}

  FORCE_INLINE operator VariantConstRef() const {
    return getUpstreamMemberConst();
  }

-  FORCE_INLINE this_type &operator=(const this_type &src) {
+  FORCE_INLINE this_type& operator=(const this_type& src) {
    getOrAddUpstreamMember().set(src);
    return *this;
  }

  template <typename TValue>
-  FORCE_INLINE typename enable_if<!is_array<TValue>::value, this_type &>::type
-  operator=(const TValue &src) {
+  FORCE_INLINE typename enable_if<!is_array<TValue>::value, this_type&>::type
+  operator=(const TValue& src) {
    getOrAddUpstreamMember().set(src);
    return *this;
  }
@@ -54,7 +54,7 @@ class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >,
  // operator=(const char*)
  // operator=(const __FlashStringHelper*)
  template <typename TChar>
-  FORCE_INLINE this_type &operator=(TChar *src) {
+  FORCE_INLINE this_type& operator=(TChar* src) {
    getOrAddUpstreamMember().set(src);
    return *this;
  }
@@ -68,7 +68,7 @@ class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >,
  }

  template <typename T>
-  FORCE_INLINE typename enable_if<!is_same<T, char *>::value &&
+  FORCE_INLINE typename enable_if<!is_same<T, char*>::value &&
                                      !ConverterNeedsWriteableRef<T>::value,
                                  T>::type
  as() const {
@@ -82,10 +82,10 @@ class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >,
  }

  template <typename T>
-  FORCE_INLINE typename enable_if<is_same<T, char *>::value, const char *>::type
+  FORCE_INLINE typename enable_if<is_same<T, char*>::value, const char*>::type
  ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()")
      as() const {
-    return as<const char *>();
+    return as<const char*>();
  }

  template <typename T>
@@ -122,15 +122,15 @@ class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >,
  // remove(const char*) const
  // remove(const __FlashStringHelper*) const
  template <typename TChar>
-  FORCE_INLINE typename enable_if<IsString<TChar *>::value>::type remove(
-      TChar *key) const {
+  FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove(
+      TChar* key) const {
    getUpstreamMember().remove(key);
  }
  // remove(const std::string&) const
  // remove(const String&) const
  template <typename TString>
  FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
-      const TString &key) const {
+      const TString& key) const {
    getUpstreamMember().remove(key);
  }

@@ -144,7 +144,7 @@ class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >,
  }

  template <typename TValue>
-  FORCE_INLINE bool set(const TValue &value) {
+  FORCE_INLINE bool set(const TValue& value) {
    return getOrAddUpstreamMember().set(value);
  }

@@ -152,7 +152,7 @@ class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >,
  // set(const char*) const
  // set(const __FlashStringHelper*) const
  template <typename TChar>
-  FORCE_INLINE bool set(TChar *value) {
+  FORCE_INLINE bool set(TChar* value) {
    return getOrAddUpstreamMember().set(value);
  }

@@ -163,16 +163,16 @@ class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >,
  using ArrayShortcuts<MemberProxy<TObject, TStringRef> >::add;

 protected:
-  FORCE_INLINE MemoryPool *getPool() const {
+  FORCE_INLINE MemoryPool* getPool() const {
    return VariantAttorney::getPool(_object);
  }

-  FORCE_INLINE VariantData *getData() const {
+  FORCE_INLINE VariantData* getData() const {
    return variantGetMember(VariantAttorney::getData(_object),
                            adaptString(_key));
  }

-  FORCE_INLINE VariantData *getOrCreateData() const {
+  FORCE_INLINE VariantData* getOrCreateData() const {
    return variantGetOrAddMember(VariantAttorney::getOrCreateData(_object),
                                 _key, VariantAttorney::getPool(_object));
  }
@@ -190,7 +190,7 @@ class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >,
    return VariantRef(getPool(), getOrCreateData());
  }

-  friend void convertToJson(const this_type &src, VariantRef dst) {
+  friend void convertToJson(const this_type& src, VariantRef dst) {
    dst.set(src.getUpstreamMemberConst());
  }

--- a/src/ArduinoJson/Object/ObjectFunctions.hpp
+++ b/src/ArduinoJson/Object/ObjectFunctions.hpp
@@ -9,7 +9,7 @@
 namespace ARDUINOJSON_NAMESPACE {

 template <typename TAdaptedString>
-inline VariantData *objectGetMember(const CollectionData *obj,
+inline VariantData* objectGetMember(const CollectionData* obj,
                                    TAdaptedString key) {
  if (!obj)
    return 0;
@@ -17,7 +17,7 @@ inline VariantData *objectGetMember(const CollectionData *obj,
 }

 template <typename TAdaptedString>
-void objectRemove(CollectionData *obj, TAdaptedString key) {
+void objectRemove(CollectionData* obj, TAdaptedString key) {
  if (!obj)
    return;
  obj->removeMember(key);
--- a/src/ArduinoJson/Object/ObjectIterator.hpp
+++ b/src/ArduinoJson/Object/ObjectIterator.hpp
@@ -11,13 +11,13 @@ namespace ARDUINOJSON_NAMESPACE {

 class PairPtr {
 public:
-  PairPtr(MemoryPool *pool, VariantSlot *slot) : _pair(pool, slot) {}
+  PairPtr(MemoryPool* pool, VariantSlot* slot) : _pair(pool, slot) {}

-  const Pair *operator->() const {
+  const Pair* operator->() const {
    return &_pair;
  }

-  const Pair &operator*() const {
+  const Pair& operator*() const {
    return _pair;
  }

@@ -29,7 +29,7 @@ class ObjectIterator {
 public:
  ObjectIterator() : _slot(0) {}

-  explicit ObjectIterator(MemoryPool *pool, VariantSlot *slot)
+  explicit ObjectIterator(MemoryPool* pool, VariantSlot* slot)
      : _pool(pool), _slot(slot) {}

  Pair operator*() const {
@@ -39,42 +39,42 @@ class ObjectIterator {
    return PairPtr(_pool, _slot);
  }

-  bool operator==(const ObjectIterator &other) const {
+  bool operator==(const ObjectIterator& other) const {
    return _slot == other._slot;
  }

-  bool operator!=(const ObjectIterator &other) const {
+  bool operator!=(const ObjectIterator& other) const {
    return _slot != other._slot;
  }

-  ObjectIterator &operator++() {
+  ObjectIterator& operator++() {
    _slot = _slot->next();
    return *this;
  }

-  ObjectIterator &operator+=(size_t distance) {
+  ObjectIterator& operator+=(size_t distance) {
    _slot = _slot->next(distance);
    return *this;
  }

-  VariantSlot *internal() {
+  VariantSlot* internal() {
    return _slot;
  }

 private:
-  MemoryPool *_pool;
-  VariantSlot *_slot;
+  MemoryPool* _pool;
+  VariantSlot* _slot;
 };

 class PairConstPtr {
 public:
-  PairConstPtr(const VariantSlot *slot) : _pair(slot) {}
+  PairConstPtr(const VariantSlot* slot) : _pair(slot) {}

-  const PairConst *operator->() const {
+  const PairConst* operator->() const {
    return &_pair;
  }

-  const PairConst &operator*() const {
+  const PairConst& operator*() const {
    return _pair;
  }

@@ -86,7 +86,7 @@ class ObjectConstIterator {
 public:
  ObjectConstIterator() : _slot(0) {}

-  explicit ObjectConstIterator(const VariantSlot *slot) : _slot(slot) {}
+  explicit ObjectConstIterator(const VariantSlot* slot) : _slot(slot) {}

  PairConst operator*() const {
    return PairConst(_slot);
@@ -95,29 +95,29 @@ class ObjectConstIterator {
    return PairConstPtr(_slot);
  }

-  bool operator==(const ObjectConstIterator &other) const {
+  bool operator==(const ObjectConstIterator& other) const {
    return _slot == other._slot;
  }

-  bool operator!=(const ObjectConstIterator &other) const {
+  bool operator!=(const ObjectConstIterator& other) const {
    return _slot != other._slot;
  }

-  ObjectConstIterator &operator++() {
+  ObjectConstIterator& operator++() {
    _slot = _slot->next();
    return *this;
  }

-  ObjectConstIterator &operator+=(size_t distance) {
+  ObjectConstIterator& operator+=(size_t distance) {
    _slot = _slot->next(distance);
    return *this;
  }

-  const VariantSlot *internal() {
+  const VariantSlot* internal() {
    return _slot;
  }

 private:
-  const VariantSlot *_slot;
+  const VariantSlot* _slot;
 };
 }  // namespace ARDUINOJSON_NAMESPACE
--- a/src/ArduinoJson/Object/ObjectShortcuts.hpp
+++ b/src/ArduinoJson/Object/ObjectShortcuts.hpp
@@ -19,55 +19,55 @@ class ObjectShortcuts {
  // containsKey(const String&) const
  template <typename TString>
  FORCE_INLINE typename enable_if<IsString<TString>::value, bool>::type
-  containsKey(const TString &key) const;
+  containsKey(const TString& key) const;

  // containsKey(char*) const
  // containsKey(const char*) const
  // containsKey(const __FlashStringHelper*) const
  template <typename TChar>
-  FORCE_INLINE typename enable_if<IsString<TChar *>::value, bool>::type
-  containsKey(TChar *key) const;
+  FORCE_INLINE typename enable_if<IsString<TChar*>::value, bool>::type
+  containsKey(TChar* key) const;

  // operator[](const std::string&) const
  // operator[](const String&) const
  template <typename TString>
  FORCE_INLINE typename enable_if<IsString<TString>::value,
                                  MemberProxy<TObject, TString> >::type
-  operator[](const TString &key) const;
+  operator[](const TString& key) const;

  // operator[](char*) const
  // operator[](const char*) const
  // operator[](const __FlashStringHelper*) const
  template <typename TChar>
-  FORCE_INLINE typename enable_if<IsString<TChar *>::value,
-                                  MemberProxy<TObject, TChar *> >::type
-  operator[](TChar *key) const;
+  FORCE_INLINE typename enable_if<IsString<TChar*>::value,
+                                  MemberProxy<TObject, TChar*> >::type
+  operator[](TChar* key) const;

  // createNestedArray(const std::string&) const
  // createNestedArray(const String&) const
  template <typename TString>
-  FORCE_INLINE ArrayRef createNestedArray(const TString &key) const;
+  FORCE_INLINE ArrayRef createNestedArray(const TString& key) const;

  // createNestedArray(char*) const
  // createNestedArray(const char*) const
  // createNestedArray(const __FlashStringHelper*) const
  template <typename TChar>
-  FORCE_INLINE ArrayRef createNestedArray(TChar *key) const;
+  FORCE_INLINE ArrayRef createNestedArray(TChar* key) const;

  // createNestedObject(const std::string&) const
  // createNestedObject(const String&) const
  template <typename TString>
-  ObjectRef createNestedObject(const TString &key) const;
+  ObjectRef createNestedObject(const TString& key) const;

  // createNestedObject(char*) const
  // createNestedObject(const char*) const
  // createNestedObject(const __FlashStringHelper*) const
  template <typename TChar>
-  ObjectRef createNestedObject(TChar *key) const;
+  ObjectRef createNestedObject(TChar* key) const;

 private:
-  const TObject *impl() const {
-    return static_cast<const TObject *>(this);
+  const TObject* impl() const {
+    return static_cast<const TObject*>(this);
  }
 };
 }  // namespace ARDUINOJSON_NAMESPACE
--- a/src/ArduinoJson/Polyfills/type_traits/is_base_of.hpp
+++ b/src/ArduinoJson/Polyfills/type_traits/is_base_of.hpp
@@ -16,11 +16,11 @@ class is_base_of {
  typedef char Yes[1];
  typedef char No[2];

-  static Yes &probe(const TBase *);
-  static No &probe(...);
+  static Yes& probe(const TBase*);
+  static No& probe(...);

 public:
  static const bool value =
-      sizeof(probe(reinterpret_cast<TDerived *>(0))) == sizeof(Yes);
+      sizeof(probe(reinterpret_cast<TDerived*>(0))) == sizeof(Yes);
 };
 }  // namespace ARDUINOJSON_NAMESPACE
--- a/src/ArduinoJson/Polyfills/type_traits/is_class.hpp
+++ b/src/ArduinoJson/Polyfills/type_traits/is_class.hpp
@@ -15,9 +15,9 @@ struct is_class {
  typedef char No[2];

  template <typename U>
-  static Yes &probe(void (U::*)(void));
+  static Yes& probe(void (U::*)(void));
  template <typename>
-  static No &probe(...);
+  static No& probe(...);

 public:
  static const bool value = sizeof(probe<T>(0)) == sizeof(Yes);
--- a/src/ArduinoJson/Polyfills/type_traits/is_convertible.hpp
+++ b/src/ArduinoJson/Polyfills/type_traits/is_convertible.hpp
@@ -27,10 +27,10 @@ struct is_convertible {
  typedef char Yes[1];
  typedef char No[2];

-  static Yes &probe(To);
-  static No &probe(...);
+  static Yes& probe(To);
+  static No& probe(...);

-  static From &_from;
+  static From& _from;

 public:
  static const bool value = sizeof(probe(_from)) == sizeof(Yes);
--- a/src/ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp
+++ b/src/ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp
@@ -13,7 +13,7 @@ class Writer< ::String, void> {
  static const size_t bufferCapacity = ARDUINOJSON_STRING_BUFFER_SIZE;

 public:
-  explicit Writer(::String &str) : _destination(&str) {
+  explicit Writer(::String& str) : _destination(&str) {
    _size = 0;
  }

@@ -29,7 +29,7 @@ class Writer< ::String, void> {
    return 1;
  }

-  size_t write(const uint8_t *s, size_t n) {
+  size_t write(const uint8_t* s, size_t n) {
    for (size_t i = 0; i < n; i++) {
      write(s[i]);
    }
@@ -45,7 +45,7 @@ class Writer< ::String, void> {
  }

 private:
-  ::String *_destination;
+  ::String* _destination;
  char _buffer[bufferCapacity];
  size_t _size;
 };
--- a/src/ArduinoJson/Serialization/Writers/StaticStringWriter.hpp
+++ b/src/ArduinoJson/Serialization/Writers/StaticStringWriter.hpp
@@ -10,7 +10,7 @@ namespace ARDUINOJSON_NAMESPACE {

 class StaticStringWriter {
 public:
-  StaticStringWriter(char *buf, size_t size) : end(buf + size), p(buf) {}
+  StaticStringWriter(char* buf, size_t size) : end(buf + size), p(buf) {}

  size_t write(uint8_t c) {
    if (p >= end)
@@ -19,8 +19,8 @@ class StaticStringWriter {
    return 1;
  }

-  size_t write(const uint8_t *s, size_t n) {
-    char *begin = p;
+  size_t write(const uint8_t* s, size_t n) {
+    char* begin = p;
    while (p < end && n > 0) {
      *p++ = static_cast<char>(*s++);
      n--;
@@ -29,7 +29,7 @@ class StaticStringWriter {
  }

 private:
-  char *end;
-  char *p;
+  char* end;
+  char* p;
 };
 }  // namespace ARDUINOJSON_NAMESPACE
--- a/src/ArduinoJson/Serialization/Writers/StdStringWriter.hpp
+++ b/src/ArduinoJson/Serialization/Writers/StdStringWriter.hpp
@@ -22,19 +22,19 @@ template <typename TDestination>
 class Writer<TDestination,
             typename enable_if<is_std_string<TDestination>::value>::type> {
 public:
-  Writer(TDestination &str) : _str(&str) {}
+  Writer(TDestination& str) : _str(&str) {}

  size_t write(uint8_t c) {
    _str->operator+=(static_cast<char>(c));
    return 1;
  }

-  size_t write(const uint8_t *s, size_t n) {
-    _str->append(reinterpret_cast<const char *>(s), n);
+  size_t write(const uint8_t* s, size_t n) {
+    _str->append(reinterpret_cast<const char*>(s), n);
    return n;
  }

 private:
-  TDestination *_str;
+  TDestination* _str;
 };
 }  // namespace ARDUINOJSON_NAMESPACE
--- a/src/ArduinoJson/Serialization/serialize.hpp
+++ b/src/ArduinoJson/Serialization/serialize.hpp
@@ -16,26 +16,26 @@ size_t doSerialize(VariantConstRef source, TWriter writer) {
 }

 template <template <typename> class TSerializer, typename TDestination>
-size_t serialize(VariantConstRef source, TDestination &destination) {
+size_t serialize(VariantConstRef source, TDestination& destination) {
  Writer<TDestination> writer(destination);
  return doSerialize<TSerializer>(source, writer);
 }

 template <template <typename> class TSerializer>
 typename enable_if<!TSerializer<StaticStringWriter>::producesText, size_t>::type
-serialize(VariantConstRef source, void *buffer, size_t bufferSize) {
-  StaticStringWriter writer(reinterpret_cast<char *>(buffer), 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 enable_if<TSerializer<StaticStringWriter>::producesText, size_t>::type
-serialize(VariantConstRef source, void *buffer, size_t bufferSize) {
-  StaticStringWriter writer(reinterpret_cast<char *>(buffer), 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)
  if (n < bufferSize)
-    reinterpret_cast<char *>(buffer)[n] = 0;
+    reinterpret_cast<char*>(buffer)[n] = 0;
  return n;
 }

--- a/src/ArduinoJson/Strings/StoragePolicy.hpp
+++ b/src/ArduinoJson/Strings/StoragePolicy.hpp
@@ -11,7 +11,7 @@ namespace ARDUINOJSON_NAMESPACE {

 struct LinkStringStoragePolicy {
  template <typename TAdaptedString, typename TCallback>
-  bool store(TAdaptedString str, MemoryPool *, TCallback callback) {
+  bool store(TAdaptedString str, MemoryPool*, TCallback callback) {
    String storedString(str.data(), str.size(), String::Linked);
    callback(storedString);
    return !str.isNull();
@@ -20,7 +20,7 @@ struct LinkStringStoragePolicy {

 struct CopyStringStoragePolicy {
  template <typename TAdaptedString, typename TCallback>
-  bool store(TAdaptedString str, MemoryPool *pool, TCallback callback);
+  bool store(TAdaptedString str, MemoryPool* pool, TCallback callback);
 };

 class LinkOrCopyStringStoragePolicy : LinkStringStoragePolicy,
@@ -29,7 +29,7 @@ class LinkOrCopyStringStoragePolicy : LinkStringStoragePolicy,
  LinkOrCopyStringStoragePolicy(bool link) : _link(link) {}

  template <typename TAdaptedString, typename TCallback>
-  bool store(TAdaptedString str, MemoryPool *pool, TCallback callback) {
+  bool store(TAdaptedString str, MemoryPool* pool, TCallback callback) {
    if (_link)
      return LinkStringStoragePolicy::store(str, pool, callback);
    else
@@ -41,15 +41,15 @@ class LinkOrCopyStringStoragePolicy : LinkStringStoragePolicy,
 };

 template <typename T>
-inline CopyStringStoragePolicy getStringStoragePolicy(const T &) {
+inline CopyStringStoragePolicy getStringStoragePolicy(const T&) {
  return CopyStringStoragePolicy();
 }

-inline LinkStringStoragePolicy getStringStoragePolicy(const char *) {
+inline LinkStringStoragePolicy getStringStoragePolicy(const char*) {
  return LinkStringStoragePolicy();
 }

-inline LinkOrCopyStringStoragePolicy getStringStoragePolicy(const String &s) {
+inline LinkOrCopyStringStoragePolicy getStringStoragePolicy(const String& s) {
  return LinkOrCopyStringStoragePolicy(s.isLinked());
 }

--- a/src/ArduinoJson/Variant/VariantAttorney.hpp
+++ b/src/ArduinoJson/Variant/VariantAttorney.hpp
@@ -20,30 +20,30 @@ class VariantAttorney {
    typedef char Yes[1];
    typedef char No[2];

-    static Yes &probe(const VariantData *);
-    static No &probe(VariantData *);
+    static Yes& probe(const VariantData*);
+    static No& probe(VariantData*);

-    static TClient &client;
+    static TClient& client;

   public:
    typedef typename conditional<sizeof(probe(client.getData())) == sizeof(Yes),
-                                 const VariantData *, VariantData *>::type type;
+                                 const VariantData*, VariantData*>::type type;
  };

 public:
  template <typename TClient>
-  FORCE_INLINE static MemoryPool *getPool(TClient &client) {
+  FORCE_INLINE static MemoryPool* getPool(TClient& client) {
    return client.getPool();
  }

  template <typename TClient>
  FORCE_INLINE static typename ResultOfGetData<TClient>::type getData(
-      TClient &client) {
+      TClient& client) {
    return client.getData();
  }

  template <typename TClient>
-  FORCE_INLINE static VariantData *getOrCreateData(TClient &client) {
+  FORCE_INLINE static VariantData* getOrCreateData(TClient& client) {
    return client.getOrCreateData();
  }
 };
--- a/src/ArduinoJson/Variant/VariantCompare.hpp
+++ b/src/ArduinoJson/Variant/VariantCompare.hpp
@@ -26,7 +26,7 @@ struct Comparer<T, typename enable_if<IsString<T>::value>::type>

  explicit Comparer(T value) : rhs(value) {}

-  CompareResult visitString(const char *lhs, size_t n) {
+  CompareResult visitString(const char* lhs, size_t n) {
    int i = stringCompare(adaptString(rhs), adaptString(lhs, n));
    if (i < 0)
      return COMPARE_RESULT_GREATER;
@@ -83,11 +83,11 @@ struct Comparer<decltype(nullptr), void> : NullComparer {
 #endif

 struct ArrayComparer : ComparerBase {
-  const CollectionData *_rhs;
+  const CollectionData* _rhs;

-  explicit ArrayComparer(const CollectionData &rhs) : _rhs(&rhs) {}
+  explicit ArrayComparer(const CollectionData& rhs) : _rhs(&rhs) {}

-  CompareResult visitArray(const CollectionData &lhs) {
+  CompareResult visitArray(const CollectionData& lhs) {
    if (ArrayConstRef(&lhs) == ArrayConstRef(_rhs))
      return COMPARE_RESULT_EQUAL;
    else
@@ -96,11 +96,11 @@ struct ArrayComparer : ComparerBase {
 };

 struct ObjectComparer : ComparerBase {
-  const CollectionData *_rhs;
+  const CollectionData* _rhs;

-  explicit ObjectComparer(const CollectionData &rhs) : _rhs(&rhs) {}
+  explicit ObjectComparer(const CollectionData& rhs) : _rhs(&rhs) {}

-  CompareResult visitObject(const CollectionData &lhs) {
+  CompareResult visitObject(const CollectionData& lhs) {
    if (ObjectConstRef(&lhs) == ObjectConstRef(_rhs))
      return COMPARE_RESULT_EQUAL;
    else
@@ -109,13 +109,13 @@ struct ObjectComparer : ComparerBase {
 };

 struct RawComparer : ComparerBase {
-  const char *_rhsData;
+  const char* _rhsData;
  size_t _rhsSize;

-  explicit RawComparer(const char *rhsData, size_t rhsSize)
+  explicit RawComparer(const char* rhsData, size_t rhsSize)
      : _rhsData(rhsData), _rhsSize(rhsSize) {}

-  CompareResult visitRawJson(const char *lhsData, size_t lhsSize) {
+  CompareResult visitRawJson(const char* lhsData, size_t lhsSize) {
    size_t size = _rhsSize < lhsSize ? _rhsSize : lhsSize;
    int n = memcmp(lhsData, _rhsData, size);
    if (n < 0)
@@ -132,12 +132,12 @@ struct VariantComparer : ComparerBase {

  explicit VariantComparer(VariantConstRef value) : rhs(value) {}

-  CompareResult visitArray(const CollectionData &lhs) {
+  CompareResult visitArray(const CollectionData& lhs) {
    ArrayComparer comparer(lhs);
    return accept(comparer);
  }

-  CompareResult visitObject(const CollectionData &lhs) {
+  CompareResult visitObject(const CollectionData& lhs) {
    ObjectComparer comparer(lhs);
    return accept(comparer);
  }
@@ -147,12 +147,12 @@ struct VariantComparer : ComparerBase {
    return accept(comparer);
  }

-  CompareResult visitString(const char *lhs, size_t) {
-    Comparer<const char *> comparer(lhs);
+  CompareResult visitString(const char* lhs, size_t) {
+    Comparer<const char*> comparer(lhs);
    return accept(comparer);
  }

-  CompareResult visitRawJson(const char *lhsData, size_t lhsSize) {
+  CompareResult visitRawJson(const char* lhsData, size_t lhsSize) {
    RawComparer comparer(lhsData, lhsSize);
    return accept(comparer);
  }
@@ -179,7 +179,7 @@ struct VariantComparer : ComparerBase {

 private:
  template <typename TComparer>
-  CompareResult accept(TComparer &comparer) {
+  CompareResult accept(TComparer& comparer) {
    CompareResult reversedResult =
        variantAccept(VariantAttorney::getData(rhs), comparer);
    switch (reversedResult) {
@@ -197,12 +197,12 @@ template <typename T>
 struct Comparer<
    T, typename enable_if<is_convertible<T, VariantConstRef>::value>::type>
    : VariantComparer {
-  explicit Comparer(const T &value)
+  explicit Comparer(const T& value)
      : VariantComparer(value.operator VariantConstRef()) {}
 };

 template <typename T>
-CompareResult compare(VariantConstRef lhs, const T &rhs) {
+CompareResult compare(VariantConstRef lhs, const T& rhs) {
  Comparer<T> comparer(rhs);
  return variantAccept(VariantAttorney::getData(lhs), comparer);
 }
--- a/src/ArduinoJson/Variant/VariantContent.hpp
+++ b/src/ArduinoJson/Variant/VariantContent.hpp
@@ -39,7 +39,7 @@ enum {
 };

 struct RawData {
-  const char *data;
+  const char* data;
  size_t size;
 };

@@ -50,7 +50,7 @@ union VariantContent {
  Integer asSignedInteger;
  CollectionData asCollection;
  struct {
-    const char *data;
+    const char* data;
    size_t size;
  } asString;
 };
--- a/src/ArduinoJson/Variant/VariantData.hpp
+++ b/src/ArduinoJson/Variant/VariantData.hpp
@@ -37,13 +37,13 @@ class VariantData {
    _flags = VALUE_IS_NULL;
  }

-  void operator=(const VariantData &src) {
+  void operator=(const VariantData& src) {
    _content = src._content;
    _flags = uint8_t((_flags & OWNED_KEY_BIT) | (src._flags & ~OWNED_KEY_BIT));
  }

  template <typename TVisitor>
-  typename TVisitor::result_type accept(TVisitor &visitor) const {
+  typename TVisitor::result_type accept(TVisitor& visitor) const {
    switch (type()) {
      case VALUE_IS_FLOAT:
        return visitor.visitFloat(_content.asFloat);
@@ -88,27 +88,27 @@ class VariantData {

  bool asBoolean() const;

-  CollectionData *asArray() {
+  CollectionData* asArray() {
    return isArray() ? &_content.asCollection : 0;
  }

-  const CollectionData *asArray() const {
-    return const_cast<VariantData *>(this)->asArray();
+  const CollectionData* asArray() const {
+    return const_cast<VariantData*>(this)->asArray();
  }

-  const CollectionData *asCollection() const {
+  const CollectionData* asCollection() const {
    return isCollection() ? &_content.asCollection : 0;
  }

-  CollectionData *asObject() {
+  CollectionData* asObject() {
    return isObject() ? &_content.asCollection : 0;
  }

-  const CollectionData *asObject() const {
-    return const_cast<VariantData *>(this)->asObject();
+  const CollectionData* asObject() const {
+    return const_cast<VariantData*>(this)->asObject();
  }

-  bool copyFrom(const VariantData &src, MemoryPool *pool);
+  bool copyFrom(const VariantData& src, MemoryPool* pool);

  bool isArray() const {
    return (_flags & VALUE_IS_ARRAY) != 0;
@@ -177,7 +177,7 @@ class VariantData {
    _content.asFloat = value;
  }

-  void setLinkedRaw(SerializedValue<const char *> value) {
+  void setLinkedRaw(SerializedValue<const char*> value) {
    if (value.data()) {
      setType(VALUE_IS_LINKED_RAW);
      _content.asString.data = value.data();
@@ -188,8 +188,8 @@ class VariantData {
  }

  template <typename T>
-  bool storeOwnedRaw(SerializedValue<T> value, MemoryPool *pool) {
-    const char *dup = pool->saveString(adaptString(value.data(), value.size()));
+  bool storeOwnedRaw(SerializedValue<T> value, MemoryPool* pool) {
+    const char* dup = pool->saveString(adaptString(value.data(), value.size()));
    if (dup) {
      setType(VALUE_IS_OWNED_RAW);
      _content.asString.data = dup;
@@ -227,13 +227,13 @@ class VariantData {
    _content.asString.size = s.size();
  }

-  CollectionData &toArray() {
+  CollectionData& toArray() {
    setType(VALUE_IS_ARRAY);
    _content.asCollection.clear();
    return _content.asCollection;
  }

-  CollectionData &toObject() {
+  CollectionData& toObject() {
    setType(VALUE_IS_OBJECT);
    _content.asCollection.clear();
    return _content.asCollection;
@@ -258,7 +258,7 @@ class VariantData {
    return isCollection() ? _content.asCollection.size() : 0;
  }

-  VariantData *addElement(MemoryPool *pool) {
+  VariantData* addElement(MemoryPool* pool) {
    if (isNull())
      toArray();
    if (!isArray())
@@ -266,12 +266,12 @@ class VariantData {
    return _content.asCollection.addElement(pool);
  }

-  VariantData *getElement(size_t index) const {
-    const CollectionData *col = asArray();
+  VariantData* getElement(size_t index) const {
+    const CollectionData* col = asArray();
    return col ? col->getElement(index) : 0;
  }

-  VariantData *getOrAddElement(size_t index, MemoryPool *pool) {
+  VariantData* getOrAddElement(size_t index, MemoryPool* pool) {
    if (isNull())
      toArray();
    if (!isArray())
@@ -280,13 +280,13 @@ class VariantData {
  }

  template <typename TAdaptedString>
-  VariantData *getMember(TAdaptedString key) const {
-    const CollectionData *col = asObject();
+  VariantData* getMember(TAdaptedString key) const {
+    const CollectionData* col = asObject();
    return col ? col->getMember(key) : 0;
  }

  template <typename TAdaptedString, typename TStoragePolicy>
-  VariantData *getOrAddMember(TAdaptedString key, MemoryPool *pool,
+  VariantData* getOrAddMember(TAdaptedString key, MemoryPool* pool,
                              TStoragePolicy storage_policy) {
    if (isNull())
      toObject();
@@ -307,7 +307,7 @@ class VariantData {
  }

  template <typename TAdaptedString, typename TStoragePolicy>
-  inline bool storeString(TAdaptedString value, MemoryPool *pool,
+  inline bool storeString(TAdaptedString value, MemoryPool* pool,
                          TStoragePolicy storage) {
    if (value.isNull()) {
      setNull();
@@ -324,7 +324,7 @@ class VariantData {
  }

  struct VariantStringSetter {
-    VariantStringSetter(VariantData *instance) : _instance(instance) {}
+    VariantStringSetter(VariantData* instance) : _instance(instance) {}

    template <typename TStoredString>
    void operator()(TStoredString s) {
@@ -334,7 +334,7 @@ class VariantData {
        _instance->setNull();
    }

-    VariantData *_instance;
+    VariantData* _instance;
  };
 };

--- a/src/ArduinoJson/Variant/VariantFunctions.hpp
+++ b/src/ArduinoJson/Variant/VariantFunctions.hpp
@@ -12,16 +12,16 @@
 namespace ARDUINOJSON_NAMESPACE {

 template <typename TVisitor>
-inline typename TVisitor::result_type variantAccept(const VariantData *var,
-                                                    TVisitor &visitor) {
+inline typename TVisitor::result_type variantAccept(const VariantData* var,
+                                                    TVisitor& visitor) {
  if (var != 0)
    return var->accept(visitor);
  else
    return visitor.visitNull();
 }

-inline bool variantCopyFrom(VariantData *dst, const VariantData *src,
-                            MemoryPool *pool) {
+inline bool variantCopyFrom(VariantData* dst, const VariantData* src,
+                            MemoryPool* pool) {
  if (!dst)
    return false;
  if (!src) {
@@ -31,51 +31,51 @@ inline bool variantCopyFrom(VariantData *dst, const VariantData *src,
  return dst->copyFrom(*src, pool);
 }

-inline void variantSetNull(VariantData *var) {
+inline void variantSetNull(VariantData* var) {
  if (!var)
    return;
  var->setNull();
 }

 template <typename TAdaptedString, typename TStoragePolicy>
-inline bool variantSetString(VariantData *var, TAdaptedString value,
-                             MemoryPool *pool, TStoragePolicy storage_policy) {
+inline bool variantSetString(VariantData* var, TAdaptedString value,
+                             MemoryPool* pool, TStoragePolicy storage_policy) {
  return var != 0 ? var->storeString(value, pool, storage_policy) : 0;
 }

-inline size_t variantSize(const VariantData *var) {
+inline size_t variantSize(const VariantData* var) {
  return var != 0 ? var->size() : 0;
 }

-inline CollectionData *variantToArray(VariantData *var) {
+inline CollectionData* variantToArray(VariantData* var) {
  if (!var)
    return 0;
  return &var->toArray();
 }

-inline CollectionData *variantToObject(VariantData *var) {
+inline CollectionData* variantToObject(VariantData* var) {
  if (!var)
    return 0;
  return &var->toObject();
 }

-inline VariantData *variantGetElement(const VariantData *var, size_t index) {
+inline VariantData* variantGetElement(const VariantData* var, size_t index) {
  return var != 0 ? var->getElement(index) : 0;
 }

-inline NO_INLINE VariantData *variantAddElement(VariantData *var,
-                                                MemoryPool *pool) {
+inline NO_INLINE VariantData* variantAddElement(VariantData* var,
+                                                MemoryPool* pool) {
  return var != 0 ? var->addElement(pool) : 0;
 }

-inline NO_INLINE VariantData *variantGetOrAddElement(VariantData *var,
+inline NO_INLINE VariantData* variantGetOrAddElement(VariantData* var,
                                                     size_t index,
-                                                     MemoryPool *pool) {
+                                                     MemoryPool* pool) {
  return var != 0 ? var->getOrAddElement(index, pool) : 0;
 }

 template <typename AdaptedString>
-VariantData *variantGetMember(const VariantData *var, AdaptedString key) {
+VariantData* variantGetMember(const VariantData* var, AdaptedString key) {
  if (!var)
    return 0;
  return var->getMember(key);
@@ -84,8 +84,8 @@ VariantData *variantGetMember(const VariantData *var, AdaptedString key) {
 // TODO: this function is inconsitent with the others:
 // it should take an adapted string
 template <typename TChar>
-VariantData *variantGetOrAddMember(VariantData *var, TChar *key,
-                                   MemoryPool *pool) {
+VariantData* variantGetOrAddMember(VariantData* var, TChar* key,
+                                   MemoryPool* pool) {
  if (!var)
    return 0;
  return var->getOrAddMember(adaptString(key), pool,
@@ -93,28 +93,28 @@ VariantData *variantGetOrAddMember(VariantData *var, TChar *key,
 }

 template <typename TString>
-VariantData *variantGetOrAddMember(VariantData *var, const TString &key,
-                                   MemoryPool *pool) {
+VariantData* variantGetOrAddMember(VariantData* var, const TString& key,
+                                   MemoryPool* pool) {
  if (!var)
    return 0;
  return var->getOrAddMember(adaptString(key), pool,
                             getStringStoragePolicy(key));
 }

-inline bool variantIsNull(const VariantData *var) {
+inline bool variantIsNull(const VariantData* var) {
  return var == 0 || var->isNull();
 }

-inline size_t variantNesting(const VariantData *var) {
+inline size_t variantNesting(const VariantData* var) {
  if (!var)
    return 0;

-  const CollectionData *collection = var->asCollection();
+  const CollectionData* collection = var->asCollection();
  if (!collection)
    return 0;

  size_t maxChildNesting = 0;
-  for (const VariantSlot *s = collection->head(); s; s = s->next()) {
+  for (const VariantSlot* s = collection->head(); s; s = s->next()) {
    size_t childNesting = variantNesting(s->data());
    if (childNesting > maxChildNesting)
      maxChildNesting = childNesting;
--- a/src/ArduinoJson/Variant/VariantImpl.hpp
+++ b/src/ArduinoJson/Variant/VariantImpl.hpp
@@ -83,7 +83,7 @@ inline String VariantData::asString() const {
  }
 }

-inline bool VariantData::copyFrom(const VariantData &src, MemoryPool *pool) {
+inline bool VariantData::copyFrom(const VariantData& src, MemoryPool* pool) {
  switch (src.type()) {
    case VALUE_IS_ARRAY:
      return toArray().copyFrom(src._content.asCollection, pool);
@@ -131,9 +131,9 @@ inline bool VariantRef::set(char value) const {

 // TODO: move somewhere else
 template <typename TAdaptedString, typename TCallback>
-bool CopyStringStoragePolicy::store(TAdaptedString str, MemoryPool *pool,
+bool CopyStringStoragePolicy::store(TAdaptedString str, MemoryPool* pool,
                                    TCallback callback) {
-  const char *copy = pool->saveString(str);
+  const char* copy = pool->saveString(str);
  String storedString(copy, str.size(), String::Copied);
  callback(storedString);
  return copy != 0;
--- a/src/ArduinoJson/Variant/VariantOperators.hpp
+++ b/src/ArduinoJson/Variant/VariantOperators.hpp
@@ -15,7 +15,7 @@ class VariantConstRef;

 template <typename T>
 CompareResult compare(VariantConstRef lhs,
-                      const T &rhs);  // VariantCompare.cpp
+                      const T& rhs);  // VariantCompare.cpp

 struct VariantOperatorTag {};

@@ -29,7 +29,7 @@ struct VariantOperators : VariantOperatorTag {
  template <typename T>
  friend
      typename enable_if<!IsVariant<T>::value && !is_array<T>::value, T>::type
-      operator|(const TVariant &variant, const T &defaultValue) {
+      operator|(const TVariant& variant, const T& defaultValue) {
    if (variant.template is<T>())
      return variant.template as<T>();
    else
@@ -37,10 +37,10 @@ struct VariantOperators : VariantOperatorTag {
  }
  //
  // const char* operator|(JsonVariant, const char*)
-  friend const char *operator|(const TVariant &variant,
-                               const char *defaultValue) {
-    if (variant.template is<const char *>())
-      return variant.template as<const char *>();
+  friend const char* operator|(const TVariant& variant,
+                               const char* defaultValue) {
+    if (variant.template is<const char*>())
+      return variant.template as<const char*>();
    else
      return defaultValue;
  }
@@ -48,7 +48,7 @@ struct VariantOperators : VariantOperatorTag {
  // JsonVariant operator|(JsonVariant, JsonVariant)
  template <typename T>
  friend typename enable_if<IsVariant<T>::value, VariantConstRef>::type
-  operator|(const TVariant &variant, T defaultValue) {
+  operator|(const TVariant& variant, T defaultValue) {
    if (variant)
      return variant;
    else
@@ -57,133 +57,133 @@ struct VariantOperators : VariantOperatorTag {

  // value == TVariant
  template <typename T>
-  friend bool operator==(T *lhs, TVariant rhs) {
+  friend bool operator==(T* lhs, TVariant rhs) {
    return compare(rhs, lhs) == COMPARE_RESULT_EQUAL;
  }
  template <typename T>
-  friend bool operator==(const T &lhs, TVariant rhs) {
+  friend bool operator==(const T& lhs, TVariant rhs) {
    return compare(rhs, lhs) == COMPARE_RESULT_EQUAL;
  }

  // TVariant == value
  template <typename T>
-  friend bool operator==(TVariant lhs, T *rhs) {
+  friend bool operator==(TVariant lhs, T* rhs) {
    return compare(lhs, rhs) == COMPARE_RESULT_EQUAL;
  }
  template <typename T>
  friend
      typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
-      operator==(TVariant lhs, const T &rhs) {
+      operator==(TVariant lhs, const T& rhs) {
    return compare(lhs, rhs) == COMPARE_RESULT_EQUAL;
  }

  // value != TVariant
  template <typename T>
-  friend bool operator!=(T *lhs, TVariant rhs) {
+  friend bool operator!=(T* lhs, TVariant rhs) {
    return compare(rhs, lhs) != COMPARE_RESULT_EQUAL;
  }
  template <typename T>
-  friend bool operator!=(const T &lhs, TVariant rhs) {
+  friend bool operator!=(const T& lhs, TVariant rhs) {
    return compare(rhs, lhs) != COMPARE_RESULT_EQUAL;
  }

  // TVariant != value
  template <typename T>
-  friend bool operator!=(TVariant lhs, T *rhs) {
+  friend bool operator!=(TVariant lhs, T* rhs) {
    return compare(lhs, rhs) != COMPARE_RESULT_EQUAL;
  }
  template <typename T>
  friend
      typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
-      operator!=(TVariant lhs, const T &rhs) {
+      operator!=(TVariant lhs, const T& rhs) {
    return compare(lhs, rhs) != COMPARE_RESULT_EQUAL;
  }

  // value < TVariant
  template <typename T>
-  friend bool operator<(T *lhs, TVariant rhs) {
+  friend bool operator<(T* lhs, TVariant rhs) {
    return compare(rhs, lhs) == COMPARE_RESULT_GREATER;
  }
  template <typename T>
-  friend bool operator<(const T &lhs, TVariant rhs) {
+  friend bool operator<(const T& lhs, TVariant rhs) {
    return compare(rhs, lhs) == COMPARE_RESULT_GREATER;
  }

  // TVariant < value
  template <typename T>
-  friend bool operator<(TVariant lhs, T *rhs) {
+  friend bool operator<(TVariant lhs, T* rhs) {
    return compare(lhs, rhs) == COMPARE_RESULT_LESS;
  }
  template <typename T>
  friend
      typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
-      operator<(TVariant lhs, const T &rhs) {
+      operator<(TVariant lhs, const T& rhs) {
    return compare(lhs, rhs) == COMPARE_RESULT_LESS;
  }

  // value <= TVariant
  template <typename T>
-  friend bool operator<=(T *lhs, TVariant rhs) {
+  friend bool operator<=(T* lhs, TVariant rhs) {
    return (compare(rhs, lhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
  }
  template <typename T>
-  friend bool operator<=(const T &lhs, TVariant rhs) {
+  friend bool operator<=(const T& lhs, TVariant rhs) {
    return (compare(rhs, lhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
  }

  // TVariant <= value
  template <typename T>
-  friend bool operator<=(TVariant lhs, T *rhs) {
+  friend bool operator<=(TVariant lhs, T* rhs) {
    return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
  }
  template <typename T>
  friend
      typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
-      operator<=(TVariant lhs, const T &rhs) {
+      operator<=(TVariant lhs, const T& rhs) {
    return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
  }

  // value > TVariant
  template <typename T>
-  friend bool operator>(T *lhs, TVariant rhs) {
+  friend bool operator>(T* lhs, TVariant rhs) {
    return compare(rhs, lhs) == COMPARE_RESULT_LESS;
  }
  template <typename T>
-  friend bool operator>(const T &lhs, TVariant rhs) {
+  friend bool operator>(const T& lhs, TVariant rhs) {
    return compare(rhs, lhs) == COMPARE_RESULT_LESS;
  }

  // TVariant > value
  template <typename T>
-  friend bool operator>(TVariant lhs, T *rhs) {
+  friend bool operator>(TVariant lhs, T* rhs) {
    return compare(lhs, rhs) == COMPARE_RESULT_GREATER;
  }
  template <typename T>
  friend
      typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
-      operator>(TVariant lhs, const T &rhs) {
+      operator>(TVariant lhs, const T& rhs) {
    return compare(lhs, rhs) == COMPARE_RESULT_GREATER;
  }

  // value >= TVariant
  template <typename T>
-  friend bool operator>=(T *lhs, TVariant rhs) {
+  friend bool operator>=(T* lhs, TVariant rhs) {
    return (compare(rhs, lhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
  }
  template <typename T>
-  friend bool operator>=(const T &lhs, TVariant rhs) {
+  friend bool operator>=(const T& lhs, TVariant rhs) {
    return (compare(rhs, lhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
  }

  // TVariant >= value
  template <typename T>
-  friend bool operator>=(TVariant lhs, T *rhs) {
+  friend bool operator>=(TVariant lhs, T* rhs) {
    return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
  }
  template <typename T>
  friend
      typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
-      operator>=(TVariant lhs, const T &rhs) {
+      operator>=(TVariant lhs, const T& rhs) {
    return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
  }
 };
--- a/src/ArduinoJson/Variant/VariantRef.hpp
+++ b/src/ArduinoJson/Variant/VariantRef.hpp
@@ -49,8 +49,8 @@ class VariantRefBase : public VariantTag {
  }

 protected:
-  VariantRefBase(TData *data) : _data(data) {}
-  TData *_data;
+  VariantRefBase(TData* data) : _data(data) {}
+  TData* _data;
 };

 class VariantConstRef : public VariantRefBase<const VariantData>,
@@ -62,21 +62,21 @@ class VariantConstRef : public VariantRefBase<const VariantData>,

 public:
  VariantConstRef() : base_type(0) {}
-  explicit VariantConstRef(const VariantData *data) : base_type(data) {}
+  explicit VariantConstRef(const VariantData* data) : base_type(data) {}

  template <typename T>
  FORCE_INLINE
-      typename enable_if<!is_same<T, char *>::value && !is_same<T, char>::value,
+      typename enable_if<!is_same<T, char*>::value && !is_same<T, char>::value,
                         T>::type
      as() const {
    return Converter<T>::fromJson(*this);
  }

  template <typename T>
-  FORCE_INLINE typename enable_if<is_same<T, char *>::value, const char *>::type
+  FORCE_INLINE typename enable_if<is_same<T, char*>::value, const char*>::type
  ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()")
      as() const {
-    return as<const char *>();
+    return as<const char*>();
  }

  template <typename T>
@@ -89,17 +89,17 @@ class VariantConstRef : public VariantRefBase<const VariantData>,

  template <typename T>
  FORCE_INLINE
-      typename enable_if<!is_same<T, char *>::value && !is_same<T, char>::value,
+      typename enable_if<!is_same<T, char*>::value && !is_same<T, char>::value,
                         bool>::type
      is() const {
    return Converter<T>::checkJson(*this);
  }

  template <typename T>
-  FORCE_INLINE typename enable_if<is_same<T, char *>::value, bool>::type
+  FORCE_INLINE typename enable_if<is_same<T, char*>::value, bool>::type
  ARDUINOJSON_DEPRECATED("Replace is<char*>() with is<const char*>()")
      is() const {
-    return is<const char *>();
+    return is<const char*>();
  }

  template <typename T>
@@ -124,7 +124,7 @@ class VariantConstRef : public VariantRefBase<const VariantData>,
  template <typename TString>
  FORCE_INLINE
      typename enable_if<IsString<TString>::value, VariantConstRef>::type
-      operator[](const TString &key) const {
+      operator[](const TString& key) const {
    return VariantConstRef(variantGetMember(_data, adaptString(key)));
  }

@@ -133,13 +133,13 @@ class VariantConstRef : public VariantRefBase<const VariantData>,
  // operator[](const __FlashStringHelper*) const
  template <typename TChar>
  FORCE_INLINE
-      typename enable_if<IsString<TChar *>::value, VariantConstRef>::type
-      operator[](TChar *key) const {
+      typename enable_if<IsString<TChar*>::value, VariantConstRef>::type
+      operator[](TChar* key) const {
    return VariantConstRef(variantGetMember(_data, adaptString(key)));
  }

 protected:
-  const VariantData *getData() const {
+  const VariantData* getData() const {
    return _data;
  }
 };
@@ -158,7 +158,7 @@ class VariantRef : public VariantRefBase<VariantData>,

 public:
  // Intenal use only
-  FORCE_INLINE VariantRef(MemoryPool *pool, VariantData *data)
+  FORCE_INLINE VariantRef(MemoryPool* pool, VariantData* data)
      : base_type(data), _pool(pool) {}

  // Creates an uninitialized VariantRef
@@ -169,7 +169,7 @@ class VariantRef : public VariantRefBase<VariantData>,
  }

  template <typename T>
-  FORCE_INLINE bool set(const T &value) const {
+  FORCE_INLINE bool set(const T& value) const {
    Converter<T>::toJson(value, *this);
    return _pool && !_pool->overflowed();
  }
@@ -179,24 +179,24 @@ class VariantRef : public VariantRefBase<VariantData>,
      set(char value) const;

  template <typename T>
-  FORCE_INLINE bool set(T *value) const {
-    Converter<T *>::toJson(value, *this);
+  FORCE_INLINE bool set(T* value) const {
+    Converter<T*>::toJson(value, *this);
    return _pool && !_pool->overflowed();
  }

  template <typename T>
  FORCE_INLINE
-      typename enable_if<!is_same<T, char *>::value && !is_same<T, char>::value,
+      typename enable_if<!is_same<T, char*>::value && !is_same<T, char>::value,
                         T>::type
      as() const {
    return Converter<T>::fromJson(*this);
  }

  template <typename T>
-  FORCE_INLINE typename enable_if<is_same<T, char *>::value, const char *>::type
+  FORCE_INLINE typename enable_if<is_same<T, char*>::value, const char*>::type
  ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()")
      as() const {
-    return as<const char *>();
+    return as<const char*>();
  }

  template <typename T>
@@ -209,17 +209,17 @@ class VariantRef : public VariantRefBase<VariantData>,

  template <typename T>
  FORCE_INLINE
-      typename enable_if<!is_same<T, char *>::value && !is_same<T, char>::value,
+      typename enable_if<!is_same<T, char*>::value && !is_same<T, char>::value,
                         bool>::type
      is() const {
    return Converter<T>::checkJson(*this);
  }

  template <typename T>
-  FORCE_INLINE typename enable_if<is_same<T, char *>::value, bool>::type
+  FORCE_INLINE typename enable_if<is_same<T, char*>::value, bool>::type
  ARDUINOJSON_DEPRECATED("Replace is<char*>() with is<const char*>()")
      is() const {
-    return is<const char *>();
+    return is<const char*>();
  }

  template <typename T>
@@ -268,8 +268,8 @@ class VariantRef : public VariantRefBase<VariantData>,
  // remove(const char*) const
  // remove(const __FlashStringHelper*) const
  template <typename TChar>
-  FORCE_INLINE typename enable_if<IsString<TChar *>::value>::type remove(
-      TChar *key) const {
+  FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove(
+      TChar* key) const {
    if (_data)
      _data->remove(adaptString(key));
  }
@@ -277,7 +277,7 @@ class VariantRef : public VariantRefBase<VariantData>,
  // remove(const String&) const
  template <typename TString>
  FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
-      const TString &key) const {
+      const TString& key) const {
    if (_data)
      _data->remove(adaptString(key));
  }
@@ -285,27 +285,27 @@ class VariantRef : public VariantRefBase<VariantData>,
  inline void shallowCopy(VariantConstRef target) {
    if (!_data)
      return;
-    const VariantData *targetData = VariantAttorney::getData(target);
+    const VariantData* targetData = VariantAttorney::getData(target);
    if (targetData)
      *_data = *targetData;
    else
      _data->setNull();
  }

-  MemoryPool *getPool() const {
+  MemoryPool* getPool() const {
    return _pool;
  }

-  VariantData *getData() const {
+  VariantData* getData() const {
    return _data;
  }

-  VariantData *getOrCreateData() const {
+  VariantData* getOrCreateData() const {
    return _data;
  }

 private:
-  MemoryPool *_pool;
+  MemoryPool* _pool;
 };

 template <>
@@ -322,7 +322,7 @@ struct Converter<VariantRef> : private VariantAttorney {
      VariantConstRef);

  static bool checkJson(VariantRef src) {
-    VariantData *data = getData(src);
+    VariantData* data = getData(src);
    return !!data;
  }

@@ -342,7 +342,7 @@ struct Converter<VariantConstRef> : private VariantAttorney {
  }

  static bool checkJson(VariantConstRef src) {
-    const VariantData *data = getData(src);
+    const VariantData* data = getData(src);
    return !!data;
  }
 };
--- a/src/ArduinoJson/Variant/Visitor.hpp
+++ b/src/ArduinoJson/Variant/Visitor.hpp
@@ -14,7 +14,7 @@ template <typename TResult>
 struct Visitor {
  typedef TResult result_type;

-  TResult visitArray(const CollectionData &) {
+  TResult visitArray(const CollectionData&) {
    return TResult();
  }

@@ -34,7 +34,7 @@ struct Visitor {
    return TResult();
  }

-  TResult visitObject(const CollectionData &) {
+  TResult visitObject(const CollectionData&) {
    return TResult();
  }

@@ -42,11 +42,11 @@ struct Visitor {
    return TResult();
  }

-  TResult visitRawJson(const char *, size_t) {
+  TResult visitRawJson(const char*, size_t) {
    return TResult();
  }

-  TResult visitString(const char *, size_t) {
+  TResult visitString(const char*, size_t) {
    return TResult();
  }
 };