Switched to Google coding style to match cpplint expectations

.clang-format

@@ -1 +0,0 @@
-BasedOnStyle: LLVM

include/ArduinoJson/Arduino/Print.hpp

@@ -12,7 +12,7 @@
 
 // This class reproduces Arduino's Print
 class Print {
-public:
+ public:
   virtual size_t write(uint8_t) = 0;
 
   size_t print(const char[]);

include/ArduinoJson/Arduino/Printable.hpp

@@ -12,7 +12,7 @@
 class Print;
 
 class Printable {
-public:
+ public:
   virtual size_t printTo(Print &p) const = 0;
 };
 

include/ArduinoJson/Internals/CompactJsonWriter.hpp

@@ -5,7 +5,7 @@
 namespace ArduinoJson {
 namespace Internals {
 class CompactJsonWriter : public JsonWriter {
-public:
+ public:
   explicit CompactJsonWriter(Print *sink) : JsonWriter(sink) {}
 
   virtual void beginArray() { _length += _sink->write('['); }

include/ArduinoJson/Internals/IndentedPrint.hpp

@@ -13,7 +13,7 @@ namespace Internals {
 // This class is used by JsonPrintable::prettyPrintTo() but can also be used
 // for your own purpose, like logging.
 class IndentedPrint : public Print {
-public:
+ public:
   IndentedPrint(Print &p) : sink(&p) {
     level = 0;
     tabSize = 2;
@@ -31,7 +31,7 @@ public:
   // Set the number of space printed for each level of indentation
   void setTabSize(uint8_t n);
 
-private:
+ private:
   Print *sink;
   uint8_t level : 4;
   uint8_t tabSize : 3;
@@ -39,8 +39,8 @@ private:
 
   size_t writeTabs();
 
-  static const int MAX_LEVEL = 15;   // because it's only 4 bits
+  static const int MAX_LEVEL = 15;    // because it's only 4 bits
-  static const int MAX_TAB_SIZE = 7; // because it's only 3 bits
+  static const int MAX_TAB_SIZE = 7;  // because it's only 3 bits
 };
 }
 }

include/ArduinoJson/Internals/JsonNode.hpp

@@ -44,12 +44,12 @@ class JsonNode {
     } asProxy;
   };
 
-public:
+ public:
   JsonNode() : next(0), type(JSON_UNDEFINED) {}
 
   JsonNode *next;
 
-  void writeTo(JsonWriter &); // TODO: <- move in JsonNodeSerializer
+  void writeTo(JsonWriter &);  // TODO: <- move in JsonNodeSerializer
 
   void setAsArray(JsonBuffer *buffer) {
     type = JSON_ARRAY;
@@ -104,16 +104,14 @@ public:
   }
 
   JsonBuffer *getContainerBuffer() {
-    if (type == JSON_PROXY)
+    if (type == JSON_PROXY) return content.asProxy.target->getContainerBuffer();
-      return content.asProxy.target->getContainerBuffer();
     return type == JSON_ARRAY || type == JSON_OBJECT
                ? content.asContainer.buffer
                : 0;
   }
 
   JsonNode *getContainerChild() {
-    if (type == JSON_PROXY)
+    if (type == JSON_PROXY) return content.asProxy.target->getContainerChild();
-      return content.asProxy.target->getContainerChild();
     return type == JSON_ARRAY || type == JSON_OBJECT ? content.asContainer.child
                                                      : 0;
   }
@@ -140,13 +138,14 @@ public:
 
   void duplicate(JsonNode *other);
 
-private:
+ private:
   JsonNodeType type;
   JsonNodeContent content;
 
-  inline void writeArrayTo(JsonWriter &); // TODO: <- move in JsonNodeSerializer
+  inline void writeArrayTo(
-  inline void
+      JsonWriter &);  // TODO: <- move in JsonNodeSerializer
-  writeObjectTo(JsonWriter &); // TODO: <- move in JsonNodeSerializer
+  inline void writeObjectTo(
+      JsonWriter &);  // TODO: <- move in JsonNodeSerializer
 
   void setAsProxyOfSelf();
 

include/ArduinoJson/Internals/JsonNodeIterator.hpp

@@ -6,7 +6,7 @@ namespace ArduinoJson {
 namespace Internals {
 // TODO: replace by JsonArrayIterator and JsonObjectIterator
 class JsonNodeIterator {
-public:
+ public:
   explicit JsonNodeIterator(JsonNode *node) : _node(node) {}
 
   bool operator!=(const JsonNodeIterator &other) const {
@@ -19,7 +19,7 @@ public:
 
   JsonNode *operator->() const { return _node; }
 
-private:
+ private:
   JsonNode *_node;
 };
 }

include/ArduinoJson/Internals/JsonNodeWrapper.hpp

@@ -9,12 +9,12 @@ namespace Internals {
 class JsonNodeWrapper {
   friend class JsonValue;
 
-public:
+ public:
   JsonNodeWrapper() : _node(0) {}
 
   explicit JsonNodeWrapper(JsonNode *node) : _node(node) {}
 
-protected:
+ protected:
   void duplicate(const JsonNodeWrapper &other) {
     if (!_node) {
       _node = other._node;

include/ArduinoJson/Internals/JsonParser.hpp

@@ -9,12 +9,12 @@ namespace Internals {
 class JsonNode;
 
 class JsonParser {
-public:
+ public:
   JsonParser(JsonBuffer *buffer, char *json) : _buffer(buffer), _ptr(json) {}
 
   JsonNode *parseAnything();
 
-private:
+ private:
   JsonBuffer *_buffer;
   char *_ptr;
 

include/ArduinoJson/Internals/JsonWriter.hpp

@@ -5,7 +5,7 @@
 namespace ArduinoJson {
 namespace Internals {
 class JsonWriter {
-public:
+ public:
   explicit JsonWriter(Print *sink) : _sink(sink), _length(0) {}
 
   size_t bytesWritten() { return _length; }
@@ -31,7 +31,7 @@ public:
 
   void writeEmptyObject() { _length += _sink->print("{}"); }
 
-protected:
+ protected:
   Print *_sink;
   size_t _length;
 };

include/ArduinoJson/Internals/PrettyJsonWriter.hpp

@@ -6,7 +6,7 @@
 namespace ArduinoJson {
 namespace Internals {
 class PrettyJsonWriter : public JsonWriter {
-public:
+ public:
   explicit PrettyJsonWriter(IndentedPrint *sink)
       : JsonWriter(sink), _indenter(sink) {}
 
@@ -37,7 +37,7 @@ public:
     _length += _sink->write('}');
   }
 
-private:
+ private:
   IndentedPrint *_indenter;
 
   void indent() {

include/ArduinoJson/Internals/QuotedString.hpp

@@ -10,7 +10,7 @@
 namespace ArduinoJson {
 namespace Internals {
 class QuotedString {
-public:
+ public:
   static size_t printTo(const char *, Print *);
 
   static char *extractFrom(char *input, char **end);

include/ArduinoJson/Internals/StringBuilder.hpp

@@ -10,7 +10,7 @@
 namespace ArduinoJson {
 namespace Internals {
 class StringBuilder : public Print {
-public:
+ public:
   StringBuilder(char *buf, int size)
       : buffer(buf), capacity(size - 1), length(0) {
     buffer[0] = 0;
@@ -18,7 +18,7 @@ public:
 
   virtual size_t write(uint8_t c);
 
-private:
+ private:
   char *buffer;
   int capacity;
   int length;

include/ArduinoJson/JsonArray.hpp

@@ -5,7 +5,7 @@
 
 namespace ArduinoJson {
 class JsonArray : public JsonContainer {
-public:
+ public:
   JsonArray() {}
 
   explicit JsonArray(Internals::JsonNode *node) : JsonContainer(node) {}
@@ -17,7 +17,7 @@ public:
   void add(double value, int decimals = 2);
   void add(int value) { add(static_cast<long>(value)); }
   void add(long value);
-  void add(JsonContainer nestedArray); // TODO: should allow JsonValue too
+  void add(JsonContainer nestedArray);  // TODO: should allow JsonValue too
 
   JsonArray createNestedArray();
   JsonObject createNestedObject();

include/ArduinoJson/JsonArrayIterator.hpp

@@ -8,7 +8,7 @@ class JsonArray;
 class JsonArrayIterator {
   friend class JsonArray;
 
-public:
+ public:
   explicit JsonArrayIterator(Internals::JsonNode *node) : _node(node) {}
 
   void operator++() { _node = _node->next; }
@@ -23,7 +23,7 @@ public:
     return _node != other._node;
   }
 
-private:
+ private:
   Internals::JsonNode *_node;
 };
 }

include/ArduinoJson/JsonBuffer.hpp

@@ -13,7 +13,7 @@ class JsonBuffer {
   friend class Internals::JsonNode;
   friend class Internals::JsonParser;
 
-public:
+ public:
   virtual ~JsonBuffer(){};
 
   JsonArray createArray() { return JsonArray(createArrayNode()); }
@@ -24,12 +24,12 @@ public:
 
   JsonArray parseArray(char *json);
   JsonObject parseObject(char *json);
-  JsonValue parseValue(char *json); // TODO: remove
+  JsonValue parseValue(char *json);  // TODO: remove
 
-protected:
+ protected:
   virtual void *allocateNode() = 0;
 
-private:
+ private:
   Internals::JsonNode *createNode();
 
   Internals::JsonNode *createArrayNode();

include/ArduinoJson/JsonContainer.hpp

@@ -14,7 +14,7 @@ class JsonValue;
 class JsonContainer : public Printable, public Internals::JsonNodeWrapper {
   friend class JsonArray;
 
-public:
+ public:
   JsonContainer() {}
 
   explicit JsonContainer(Internals::JsonNode *node) : JsonNodeWrapper(node) {}
@@ -30,7 +30,7 @@ public:
   size_t prettyPrintTo(ArduinoJson::Internals::IndentedPrint &print) const;
   size_t prettyPrintTo(Print &print) const;
 
-protected:
+ protected:
   Internals::JsonNodeIterator beginChildren() const {
     return Internals::JsonNodeIterator(_node ? _node->getContainerChild() : 0);
   }

include/ArduinoJson/JsonObject.hpp

@@ -5,7 +5,7 @@
 
 namespace ArduinoJson {
 class JsonObject : public JsonContainer {
-public:
+ public:
   JsonObject() {}
 
   explicit JsonObject(Internals::JsonNode *node) : JsonContainer(node) {}
@@ -22,7 +22,7 @@ public:
 
   JsonObjectIterator end() { return JsonObjectIterator(0); }
 
-private:
+ private:
   Internals::JsonNode *getOrCreateNodeAt(const char *key);
 };
 }

include/ArduinoJson/JsonObjectIterator.hpp

@@ -8,7 +8,7 @@ class JsonObject;
 class JsonObjectIterator {
   friend class JsonObject;
 
-public:
+ public:
   explicit JsonObjectIterator(Internals::JsonNode *node)
       : _objectKeyValue(node) {}
 
@@ -29,7 +29,7 @@ public:
     return _objectKeyValue != other._objectKeyValue;
   }
 
-private:
+ private:
   JsonObjectKeyValue _objectKeyValue;
 };
 }

include/ArduinoJson/JsonObjectKeyValue.hpp

@@ -4,7 +4,7 @@
 
 namespace ArduinoJson {
 class JsonObjectKeyValue {
-public:
+ public:
   explicit JsonObjectKeyValue(Internals::JsonNode *node) : _node(node) {}
 
   const char *key() const { return _node->getAsObjectKey(); }
@@ -21,7 +21,7 @@ public:
 
   Internals::JsonNode *next() { return _node->next; }
 
-private:
+ private:
   Internals::JsonNode *_node;
 };
 }

include/ArduinoJson/JsonValue.hpp

@@ -8,7 +8,7 @@ class JsonContainer;
 class JsonObject;
 
 class JsonValue : public Internals::JsonNodeWrapper {
-public:
+ public:
   JsonValue() {}
 
   explicit JsonValue(Internals::JsonNode *node) : JsonNodeWrapper(node) {}
@@ -32,6 +32,9 @@ public:
 
   void set(double value, int decimals);
 
-  template <typename T> T as() { return static_cast<T>(*this); }
+  template <typename T>
+  T as() {
+    return static_cast<T>(*this);
+  }
 };
 }

include/ArduinoJson/StaticJsonBuffer.hpp

@@ -4,10 +4,11 @@
 #include "JsonObject.hpp"
 
 namespace ArduinoJson {
-template <int CAPACITY> class StaticJsonBuffer : public JsonBuffer {
+template <int CAPACITY>
+class StaticJsonBuffer : public JsonBuffer {
   friend class JsonObject;
 
-public:
+ public:
   explicit StaticJsonBuffer() : _size(0) {}
 
   virtual ~StaticJsonBuffer() {}
@@ -16,15 +17,14 @@ public:
 
   int size() { return _size; }
 
-protected:
+ protected:
   virtual void *allocateNode() {
-    if (_size >= CAPACITY)
+    if (_size >= CAPACITY) return 0;
-      return 0;
 
     return &_buffer[_size++];
   }
 
-private:
+ private:
   Internals::JsonNode _buffer[CAPACITY];
   int _size;
 };

scripts/format-code.sh

@@ -1 +1,2 @@
-find .. -regex ".*\.[ch]pp$" -exec clang-format -i {} \;
+cd ..
+find include src test -regex ".*\.[ch]pp$" -exec clang-format -style=Google -i {} \;

src/Internals/IndentedPrint.cpp

@@ -3,25 +3,21 @@
 using namespace ArduinoJson::Internals;
 
 void IndentedPrint::indent() {
-  if (level < MAX_LEVEL)
+  if (level < MAX_LEVEL) level++;
-    level++;
 }
 
 void IndentedPrint::unindent() {
-  if (level > 0)
+  if (level > 0) level--;
-    level--;
 }
 
 void IndentedPrint::setTabSize(uint8_t n) {
-  if (n < MAX_TAB_SIZE)
+  if (n < MAX_TAB_SIZE) tabSize = n;
-    tabSize = n;
 }
 
 size_t IndentedPrint::write(uint8_t c) {
   size_t n = 0;
 
-  if (isNewLine)
+  if (isNewLine) n += writeTabs();
-    n += writeTabs();
 
   n += sink->write(c);
 
@@ -33,8 +29,7 @@ size_t IndentedPrint::write(uint8_t c) {
 inline size_t IndentedPrint::writeTabs() {
   size_t n = 0;
 
-  for (int i = 0; i < level * tabSize; i++)
+  for (int i = 0; i < level * tabSize; i++) n += sink->write(' ');
-    n += sink->write(' ');
 
   return n;
 }

src/Internals/JsonNode.cpp

@@ -9,42 +9,40 @@ using namespace ArduinoJson::Internals;
 
 void JsonNode::writeTo(JsonWriter &writer) {
   switch (type) {
-  case JSON_PROXY:
+    case JSON_PROXY:
-    content.asProxy.target->writeTo(writer);
+      content.asProxy.target->writeTo(writer);
-    break;
+      break;
 
-  case JSON_ARRAY:
+    case JSON_ARRAY:
-    writeArrayTo(writer);
+      writeArrayTo(writer);
-    break;
+      break;
 
-  case JSON_OBJECT:
+    case JSON_OBJECT:
-    writeObjectTo(writer);
+      writeObjectTo(writer);
-    break;
+      break;
 
-  case JSON_STRING:
+    case JSON_STRING:
-    writer.writeString(content.asString);
+      writer.writeString(content.asString);
-    break;
+      break;
 
-  case JSON_LONG:
+    case JSON_LONG:
-    writer.writeInteger(content.asInteger);
+      writer.writeInteger(content.asInteger);
-    break;
+      break;
 
-  case JSON_BOOLEAN:
+    case JSON_BOOLEAN:
-    writer.writeBoolean(content.asBoolean);
+      writer.writeBoolean(content.asBoolean);
-    break;
+      break;
 
-  default: // >= JSON_DOUBLE_0_DECIMALS
+    default:  // >= JSON_DOUBLE_0_DECIMALS
-    writer.writeDouble(content.asDouble, type - JSON_DOUBLE_0_DECIMALS);
+      writer.writeDouble(content.asDouble, type - JSON_DOUBLE_0_DECIMALS);
-    break;
+      break;
   }
 }
 
 void JsonNode::addChild(JsonNode *childToAdd) {
-  if (type == JSON_PROXY)
+  if (type == JSON_PROXY) return content.asProxy.target->addChild(childToAdd);
-    return content.asProxy.target->addChild(childToAdd);
 
-  if (type != JSON_ARRAY && type != JSON_OBJECT)
+  if (type != JSON_ARRAY && type != JSON_OBJECT) return;
-    return;
 
   JsonNode *lastChild = content.asContainer.child;
 
@@ -53,8 +51,7 @@ void JsonNode::addChild(JsonNode *childToAdd) {
     return;
   }
 
-  while (lastChild->next)
+  while (lastChild->next) lastChild = lastChild->next;
-    lastChild = lastChild->next;
 
   lastChild->next = childToAdd;
 }
@@ -63,8 +60,7 @@ void JsonNode::removeChild(JsonNode *childToRemove) {
   if (type == JSON_PROXY)
     return content.asProxy.target->removeChild(childToRemove);
 
-  if (type != JSON_ARRAY && type != JSON_OBJECT)
+  if (type != JSON_ARRAY && type != JSON_OBJECT) return;
-    return;
 
   if (content.asContainer.child == childToRemove) {
     content.asContainer.child = childToRemove->next;
@@ -73,8 +69,7 @@ void JsonNode::removeChild(JsonNode *childToRemove) {
 
   for (JsonNode *child = content.asContainer.child; child;
        child = child->next) {
-    if (child->next == childToRemove)
+    if (child->next == childToRemove) child->next = childToRemove->next;
-      child->next = childToRemove->next;
   }
 }
 
@@ -88,8 +83,7 @@ void JsonNode::writeArrayTo(JsonWriter &writer) {
       child->writeTo(writer);
 
       child = child->next;
-      if (!child)
+      if (!child) break;
-        break;
 
       writer.writeComma();
     }
@@ -112,8 +106,7 @@ void JsonNode::writeObjectTo(JsonWriter &writer) {
       child->content.asKeyValue.value->writeTo(writer);
 
       child = child->next;
-      if (!child)
+      if (!child) break;
-        break;
 
       writer.writeComma();
     }
@@ -126,12 +119,10 @@ void JsonNode::writeObjectTo(JsonWriter &writer) {
 
 void JsonNode::setAsProxyOfSelf() {
   JsonBuffer *buffer = content.asContainer.buffer;
-  if (!buffer)
+  if (!buffer) return;
-    return;
 
   JsonNode *newNode = buffer->createNode();
-  if (!newNode)
+  if (!newNode) return;
-    return;
 
   *newNode = *this;
 

src/Internals/JsonParser.cpp

@@ -1,6 +1,6 @@
 #include "ArduinoJson/Internals/JsonParser.hpp"
 
-#include <stdlib.h> // for strtol, strtod
+#include <stdlib.h>  // for strtol, strtod
 #include <ctype.h>
 
 #include "ArduinoJson/JsonBuffer.hpp"
@@ -9,14 +9,12 @@
 using namespace ArduinoJson::Internals;
 
 void JsonParser::skipSpaces() {
-  while (isspace(*_ptr))
+  while (isspace(*_ptr)) _ptr++;
-    _ptr++;
 }
 
 bool JsonParser::skip(char charToSkip) {
   skipSpaces();
-  if (*_ptr != charToSkip)
+  if (*_ptr != charToSkip) return false;
-    return false;
   _ptr++;
   skipSpaces();
   return true;
@@ -26,39 +24,39 @@ JsonNode *JsonParser::parseAnything() {
   skipSpaces();
 
   switch (*_ptr) {
-  case '[':
+    case '[':
-    return parseArray();
+      return parseArray();
 
-  case 't':
+    case 't':
-  case 'f':
+    case 'f':
-    return parseBoolean();
+      return parseBoolean();
 
-  case '-':
+    case '-':
-  case '.':
+    case '.':
-  case '0':
+    case '0':
-  case '1':
+    case '1':
-  case '2':
+    case '2':
-  case '3':
+    case '3':
-  case '4':
+    case '4':
-  case '5':
+    case '5':
-  case '6':
+    case '6':
-  case '7':
+    case '7':
-  case '8':
+    case '8':
-  case '9':
+    case '9':
-    return parseNumber();
+      return parseNumber();
 
-  case 'n':
+    case 'n':
-    return parseNull();
+      return parseNull();
 
-  case '{':
+    case '{':
-    return parseObject();
+      return parseObject();
 
-  case '\'':
+    case '\'':
-  case '\"':
+    case '\"':
-    return parseString();
+      return parseString();
 
-  default:
+    default:
-    return NULL; // invalid JSON
+      return NULL;  // invalid JSON
   }
 }
 
@@ -67,25 +65,20 @@ JsonNode *JsonParser::parseArray() {
 
   skip('[');
 
-  if (isEnd())
+  if (isEnd()) return 0;
-    return 0;
 
-  if (skip(']'))
+  if (skip(']')) return node;  // empty array
-    return node; // empty array
 
   for (;;) {
     JsonNode *child = parseAnything();
 
-    if (!child)
+    if (!child) return 0;  // child parsing failed
-      return 0; // child parsing failed
 
     node->addChild(child);
 
-    if (skip(']'))
+    if (skip(']')) return node;  // end of the array
-      return node; // end of the array
 
-    if (!skip(','))
+    if (!skip(',')) return 0;  // comma is missing
-      return 0; // comma is missing
   }
 }
 
@@ -103,7 +96,7 @@ JsonNode *JsonParser::parseNumber() {
   char *endOfLong;
   long longValue = strtol(_ptr, &endOfLong, 10);
 
-  if (*endOfLong == '.') // stopped on a decimal separator
+  if (*endOfLong == '.')  // stopped on a decimal separator
   {
     double value = strtod(_ptr, &_ptr);
     int decimals = _ptr - endOfLong - 1;
@@ -115,7 +108,7 @@ JsonNode *JsonParser::parseNumber() {
 }
 
 JsonNode *JsonParser::parseNull() {
-  _ptr += 4; // strlen("null")
+  _ptr += 4;  // strlen("null")
 
   return _buffer->createStringNode(0);
 }
@@ -125,41 +118,33 @@ JsonNode *JsonParser::parseObject() {
 
   skip('{');
 
-  if (isEnd())
+  if (isEnd()) return 0;  // premature ending
-    return 0; // premature ending
 
-  if (skip('}'))
+  if (skip('}')) return node;  // empty object
-    return node; // empty object
 
   for (;;) {
     JsonNode *child = parseObjectKeyValue();
 
-    if (!child)
+    if (!child) return 0;  // child parsing failed
-      return 0; // child parsing failed
 
     node->addChild(child);
 
-    if (skip('}'))
+    if (skip('}')) return node;  // end of the object
-      return node; // end of the object
 
-    if (!skip(','))
+    if (!skip(',')) return 0;  // comma is missing
-      return 0; // comma is missing
   }
 }
 
 JsonNode *JsonParser::parseObjectKeyValue() {
   const char *key = QuotedString::extractFrom(_ptr, &_ptr);
 
-  if (!key)
+  if (!key) return 0;  // failed to extract key
-    return 0; // failed to extract key
 
-  if (!skip(':'))
+  if (!skip(':')) return 0;  // colon is missing
-    return 0; // colon is missing
 
   JsonNode *value = parseAnything();
 
-  if (!value)
+  if (!value) return 0;  // value parsing failed
-    return 0; // value parsing failed
 
   return _buffer->createObjectKeyValueNode(key, value);
 }

src/Internals/QuotedString.cpp

@@ -27,8 +27,7 @@ static inline size_t printCharTo(char c, Print *p) {
 }
 
 size_t QuotedString::printTo(const char *s, Print *p) {
-  if (!s)
+  if (!s) return p->print("null");
-    return p->print("null");
 
   size_t n = p->write('\"');
 
@@ -45,10 +44,8 @@ static char unescapeChar(char c) {
   const char *p = "b\bf\fn\nr\rt\t";
 
   for (;;) {
-    if (p[0] == 0)
+    if (p[0] == 0) return c;
-      return c;
+    if (p[0] == c) return p[1];
-    if (p[0] == c)
-      return p[1];
     p += 2;
   }
 }
@@ -63,9 +60,9 @@ char *QuotedString::extractFrom(char *input, char **endPtr) {
     return 0;
   }
 
-  char stopChar = firstChar; // closing quote is the same as opening quote
+  char stopChar = firstChar;  // closing quote is the same as opening quote
 
-  char *startPtr = input + 1; // skip the quote
+  char *startPtr = input + 1;  // skip the quote
   char *readPtr = startPtr;
   char *writePtr = startPtr;
   char c;

src/Internals/StringBuilder.cpp

@@ -8,8 +8,7 @@
 using namespace ArduinoJson::Internals;
 
 size_t StringBuilder::write(uint8_t c) {
-  if (length >= capacity)
+  if (length >= capacity) return 0;
-    return 0;
 
   buffer[length++] = c;
   buffer[length] = 0;

src/JsonArray.cpp

@@ -7,8 +7,7 @@ using namespace ArduinoJson::Internals;
 
 JsonValue JsonArray::operator[](int index) const {
   for (JsonNodeIterator it = beginChildren(); it != endChildren(); ++it) {
-    if (!index)
+    if (!index) return JsonValue(*it);
-      return JsonValue(*it);
     index--;
   }
 
@@ -17,8 +16,7 @@ JsonValue JsonArray::operator[](int index) const {
 
 void JsonArray::add(bool value) {
   JsonNode *node = createNode();
-  if (!node)
+  if (!node) return;
-    return;
 
   node->setAsBoolean(value);
   addChild(node);
@@ -26,8 +24,7 @@ void JsonArray::add(bool value) {
 
 void JsonArray::add(char const *value) {
   JsonNode *node = createNode();
-  if (!node)
+  if (!node) return;
-    return;
 
   node->setAsString(value);
   addChild(node);
@@ -35,8 +32,7 @@ void JsonArray::add(char const *value) {
 
 void JsonArray::add(double value, int decimals) {
   JsonNode *node = createNode();
-  if (!node)
+  if (!node) return;
-    return;
 
   node->setAsDouble(value, decimals);
   addChild(node);
@@ -44,8 +40,7 @@ void JsonArray::add(double value, int decimals) {
 
 void JsonArray::add(long value) {
   JsonNode *node = createNode();
-  if (!node)
+  if (!node) return;
-    return;
 
   node->setAsLong(value);
   addChild(node);
@@ -54,8 +49,7 @@ void JsonArray::add(long value) {
 // TODO: we should have the same issue as in JsonValue
 void JsonArray::add(JsonContainer nestedContainer) {
   JsonNode *node = createNode();
-  if (!node)
+  if (!node) return;
-    return;
 
   node->duplicate(nestedContainer._node);
   addChild(node);
@@ -84,8 +78,7 @@ JsonObject JsonArray::createNestedObject() {
 }
 
 JsonArrayIterator JsonArray::begin() {
-  if (!_node)
+  if (!_node) return end();
-    return end();
 
   return JsonArrayIterator(_node->getContainerChild());
 }

src/JsonBuffer.cpp

@@ -13,8 +13,7 @@ JsonValue JsonBuffer::createValue() { return JsonValue(createNode()); }
 
 JsonNode *JsonBuffer::createNode() {
   void *node = allocateNode();
-  if (!node)
+  if (!node) return 0;
-    return 0;
 
   return new (node) JsonNode();
 }
@@ -37,8 +36,7 @@ JsonValue JsonBuffer::parseValue(char *json) {
 JsonNode *JsonBuffer::createArrayNode() {
   JsonNode *node = createNode();
 
-  if (node)
+  if (node) node->setAsArray(this);
-    node->setAsArray(this);
 
   return node;
 }
@@ -46,8 +44,7 @@ JsonNode *JsonBuffer::createArrayNode() {
 JsonNode *JsonBuffer::createBoolNode(bool value) {
   JsonNode *node = createNode();
 
-  if (node)
+  if (node) node->setAsBoolean(value);
-    node->setAsBoolean(value);
 
   return node;
 }
@@ -55,8 +52,7 @@ JsonNode *JsonBuffer::createBoolNode(bool value) {
 JsonNode *JsonBuffer::createDoubleNode(double value, int decimals) {
   JsonNode *node = createNode();
 
-  if (node)
+  if (node) node->setAsDouble(value, decimals);
-    node->setAsDouble(value, decimals);
 
   return node;
 }
@@ -64,8 +60,7 @@ JsonNode *JsonBuffer::createDoubleNode(double value, int decimals) {
 JsonNode *JsonBuffer::createLongNode(long value) {
   JsonNode *node = createNode();
 
-  if (node)
+  if (node) node->setAsLong(value);
-    node->setAsLong(value);
 
   return node;
 }
@@ -73,8 +68,7 @@ JsonNode *JsonBuffer::createLongNode(long value) {
 JsonNode *JsonBuffer::createObjectNode() {
   JsonNode *node = createNode();
 
-  if (node)
+  if (node) node->setAsObject(this);
-    node->setAsObject(this);
 
   return node;
 }
@@ -83,8 +77,7 @@ Internals::JsonNode *JsonBuffer::createObjectKeyValueNode(const char *key,
                                                           JsonNode *value) {
   JsonNode *node = createNode();
 
-  if (node)
+  if (node) node->setAsObjectKeyValue(key, value);
-    node->setAsObjectKeyValue(key, value);
 
   return node;
 }
@@ -92,8 +85,7 @@ Internals::JsonNode *JsonBuffer::createObjectKeyValueNode(const char *key,
 JsonNode *JsonBuffer::createStringNode(const char *value) {
   JsonNode *node = createNode();
 
-  if (node)
+  if (node) node->setAsString(value);
-    node->setAsString(value);
 
   return node;
 }

src/JsonContainer.cpp

@@ -36,32 +36,26 @@ size_t JsonContainer::prettyPrintTo(Print &print) const {
 }
 
 JsonNode *JsonContainer::createNode() {
-  if (!_node)
+  if (!_node) return 0;
-    return 0;
 
   JsonBuffer *buffer = _node->getContainerBuffer();
-  if (!buffer)
+  if (!buffer) return 0;
-    return 0;
 
   return buffer->createNode();
 }
 
 bool JsonContainer::operator==(const JsonContainer &other) const {
-  if (_node == other._node)
+  if (_node == other._node) return true;
-    return true;
+  if (!_node || !other._node) return false;
-  if (!_node || !other._node)
-    return false;
   return _node->getProxyTarget() == other._node->getProxyTarget();
 }
 
 void JsonContainer::addChild(JsonNode *childToAdd) {
-  if (_node)
+  if (_node) _node->addChild(childToAdd);
-    _node->addChild(childToAdd);
 }
 
 void JsonContainer::removeChild(JsonNode *childToRemove) {
-  if (_node)
+  if (_node) _node->removeChild(childToRemove);
-    _node->removeChild(childToRemove);
 }
 
 size_t JsonContainer::size() const {

src/JsonObject.cpp

@@ -1,6 +1,6 @@
 #include "ArduinoJson/JsonObject.hpp"
 
-#include <string.h> // for strcmp
+#include <string.h>  // for strcmp
 
 #include "ArduinoJson/JsonBuffer.hpp"
 #include "ArduinoJson/JsonValue.hpp"
@@ -28,8 +28,7 @@ void JsonObject::remove(char const *key) {
 JsonArray JsonObject::createNestedArray(char const *key) {
   JsonNode *node = getOrCreateNodeAt(key);
 
-  if (node)
+  if (node) node->setAsArray(_node->getContainerBuffer());
-    node->setAsArray(_node->getContainerBuffer());
 
   return JsonArray(node);
 }
@@ -37,8 +36,7 @@ JsonArray JsonObject::createNestedArray(char const *key) {
 JsonObject JsonObject::createNestedObject(char const *key) {
   JsonNode *node = getOrCreateNodeAt(key);
 
-  if (node)
+  if (node) node->setAsObject(_node->getContainerBuffer());
-    node->setAsObject(_node->getContainerBuffer());
 
   return JsonObject(node);
 }
@@ -47,17 +45,14 @@ JsonNode *JsonObject::getOrCreateNodeAt(const char *key) {
   for (JsonNodeIterator it = beginChildren(); it != endChildren(); ++it) {
     const char *childKey = it->getAsObjectKey();
 
-    if (!strcmp(childKey, key))
+    if (!strcmp(childKey, key)) return it->getAsObjectValue();
-      return it->getAsObjectValue();
   }
 
   JsonNode *newValueNode = createNode();
-  if (!newValueNode)
+  if (!newValueNode) return 0;
-    return 0;
 
   JsonNode *newKeyNode = createNode();
-  if (!newKeyNode)
+  if (!newKeyNode) return 0;
-    return 0;
 
   newKeyNode->setAsObjectKeyValue(key, newValueNode);
 

src/JsonValue.cpp

@@ -7,23 +7,19 @@
 using namespace ArduinoJson;
 
 void JsonValue::operator=(bool value) {
-  if (_node)
+  if (_node) _node->setAsBoolean(value);
-    _node->setAsBoolean(value);
 }
 
 void JsonValue::operator=(char const *value) {
-  if (_node)
+  if (_node) _node->setAsString(value);
-    _node->setAsString(value);
 }
 
 void JsonValue::set(double value, int decimals) {
-  if (_node)
+  if (_node) _node->setAsDouble(value, decimals);
-    _node->setAsDouble(value, decimals);
 }
 
 void JsonValue::operator=(int value) {
-  if (_node)
+  if (_node) _node->setAsLong(value);
-    _node->setAsLong(value);
 }
 
 JsonValue::operator bool() const {

test/Issue10.cpp

@@ -12,7 +12,7 @@ struct Person {
 };
 
 class Issue10 : public testing::Test {
-protected:
+ protected:
   virtual void SetUp() {
     Person boss;
     boss.id = 1;
@@ -47,8 +47,8 @@ TEST_F(Issue10, PopulateArrayByAddingAnObject) {
     object["id"] = persons[i].id;
     object["name"] = persons[i].name;
 
-    array.add(object); // <- adds a reference to an existing objet (creates 2
+    array.add(object);  // <- adds a reference to an existing objet (creates 2
-                       // extra proxy nodes)
+                        // extra proxy nodes)
   }
 
   checkJsonString(array);

test/JsonArray_Container_Tests.cpp

@@ -5,16 +5,18 @@
 using namespace ArduinoJson;
 
 class JsonArray_Container_Tests : public ::testing::Test {
-protected:
+ protected:
   virtual void SetUp() { array = json.createArray(); }
 
   void nodeCountMustBe(int expected) { EXPECT_EQ(expected, json.size()); }
 
-  template <typename T> void firstElementMustBe(T expected) {
+  template <typename T>
+  void firstElementMustBe(T expected) {
     elementAtIndexMustBe(0, expected);
   }
 
-  template <typename T> void secondElementMustBe(T expected) {
+  template <typename T>
+  void secondElementMustBe(T expected) {
     elementAtIndexMustBe(1, expected);
   }
 
@@ -23,8 +25,9 @@ protected:
   StaticJsonBuffer<42> json;
   JsonArray array;
 
-private:
+ private:
-  template <typename T> void elementAtIndexMustBe(int index, T expected) {
+  template <typename T>
+  void elementAtIndexMustBe(int index, T expected) {
     EXPECT_EQ(expected, array[index].as<T>());
   }
 };

test/JsonArray_Iterator_Tests.cpp

@@ -15,10 +15,10 @@ TEST(JsonArray_Iterator_Test, SimpleTest) {
   JsonArrayIterator end = array.end();
 
   EXPECT_NE(end, it);
-  EXPECT_EQ(12, (*it).as<int>()); // TODO: use ->
+  EXPECT_EQ(12, (*it).as<int>());  // TODO: use ->
   ++it;
   EXPECT_NE(end, it);
-  EXPECT_EQ(34, (*it).as<int>()); // TODO: use ->
+  EXPECT_EQ(34, (*it).as<int>());  // TODO: use ->
   ++it;
   EXPECT_EQ(array.end(), it);
 }

test/JsonArray_PrettyPrintTo_Tests.cpp

@@ -12,7 +12,7 @@
 using namespace ArduinoJson;
 
 class JsonArray_PrettyPrintTo_Tests : public testing::Test {
-protected:
+ protected:
   JsonArray array;
   StaticJsonBuffer<30> json;
 
@@ -24,7 +24,7 @@ protected:
     EXPECT_EQ(strlen(expected), n);
   }
 
-private:
+ private:
   char buffer[256];
 };
 
@@ -33,29 +33,32 @@ TEST_F(JsonArray_PrettyPrintTo_Tests, Empty) { outputMustBe("[]"); }
 TEST_F(JsonArray_PrettyPrintTo_Tests, OneElement) {
   array.add(1);
 
-  outputMustBe("[\r\n"
+  outputMustBe(
-               "  1\r\n"
+      "[\r\n"
-               "]");
+      "  1\r\n"
+      "]");
 }
 
 TEST_F(JsonArray_PrettyPrintTo_Tests, TwoElements) {
   array.add(1);
   array.add(2);
 
-  outputMustBe("[\r\n"
+  outputMustBe(
-               "  1,\r\n"
+      "[\r\n"
-               "  2\r\n"
+      "  1,\r\n"
-               "]");
+      "  2\r\n"
+      "]");
 }
 
 TEST_F(JsonArray_PrettyPrintTo_Tests, EmptyNestedArrays) {
   array.createNestedArray();
   array.createNestedArray();
 
-  outputMustBe("[\r\n"
+  outputMustBe(
-               "  [],\r\n"
+      "[\r\n"
-               "  []\r\n"
+      "  [],\r\n"
-               "]");
+      "  []\r\n"
+      "]");
 }
 
 TEST_F(JsonArray_PrettyPrintTo_Tests, NestedArrays) {
@@ -66,13 +69,14 @@ TEST_F(JsonArray_PrettyPrintTo_Tests, NestedArrays) {
   JsonObject nested2 = array.createNestedObject();
   nested2["key"] = 3;
 
-  outputMustBe("[\r\n"
+  outputMustBe(
-               "  [\r\n"
+      "[\r\n"
-               "    1,\r\n"
+      "  [\r\n"
-               "    2\r\n"
+      "    1,\r\n"
-               "  ],\r\n"
+      "    2\r\n"
-               "  {\r\n"
+      "  ],\r\n"
-               "    \"key\": 3\r\n"
+      "  {\r\n"
-               "  }\r\n"
+      "    \"key\": 3\r\n"
-               "]");
+      "  }\r\n"
+      "]");
 }

test/JsonArray_PrintTo_Tests.cpp

@@ -11,7 +11,7 @@
 using namespace ArduinoJson;
 
 class JsonArray_PrintTo_Tests : public testing::Test {
-protected:
+ protected:
   JsonArray array;
   StaticJsonBuffer<3> json;
 
@@ -23,7 +23,7 @@ protected:
     EXPECT_EQ(strlen(expected), n);
   }
 
-private:
+ private:
   char buffer[256];
 };
 

test/JsonObject_Container_Tests.cpp

@@ -5,7 +5,7 @@
 using namespace ArduinoJson;
 
 class JsonObject_Container_Tests : public ::testing::Test {
-protected:
+ protected:
   virtual void SetUp() { object = json.createObject(); }
 
   StaticJsonBuffer<42> json;

test/JsonObject_PrettyPrintTo_Tests.cpp

@@ -11,7 +11,7 @@
 using namespace ArduinoJson;
 
 class JsonObject_PrettyPrintTo_Tests : public testing::Test {
-protected:
+ protected:
   JsonObject object;
   StaticJsonBuffer<30> json;
 
@@ -23,7 +23,7 @@ protected:
     EXPECT_EQ(strlen(expected), n);
   }
 
-private:
+ private:
   char buffer[256];
 };
 
@@ -32,29 +32,32 @@ TEST_F(JsonObject_PrettyPrintTo_Tests, EmptyObject) { outputMustBe("{}"); }
 TEST_F(JsonObject_PrettyPrintTo_Tests, OneMember) {
   object["key"] = "value";
 
-  outputMustBe("{\r\n"
+  outputMustBe(
-               "  \"key\": \"value\"\r\n"
+      "{\r\n"
-               "}");
+      "  \"key\": \"value\"\r\n"
+      "}");
 }
 
 TEST_F(JsonObject_PrettyPrintTo_Tests, TwoMembers) {
   object["key1"] = "value1";
   object["key2"] = "value2";
 
-  outputMustBe("{\r\n"
+  outputMustBe(
-               "  \"key1\": \"value1\",\r\n"
+      "{\r\n"
-               "  \"key2\": \"value2\"\r\n"
+      "  \"key1\": \"value1\",\r\n"
-               "}");
+      "  \"key2\": \"value2\"\r\n"
+      "}");
 }
 
 TEST_F(JsonObject_PrettyPrintTo_Tests, EmptyNestedContainers) {
   object.createNestedObject("key1");
   object.createNestedArray("key2");
 
-  outputMustBe("{\r\n"
+  outputMustBe(
-               "  \"key1\": {},\r\n"
+      "{\r\n"
-               "  \"key2\": []\r\n"
+      "  \"key1\": {},\r\n"
-               "}");
+      "  \"key2\": []\r\n"
+      "}");
 }
 
 TEST_F(JsonObject_PrettyPrintTo_Tests, NestedContainers) {
@@ -64,12 +67,13 @@ TEST_F(JsonObject_PrettyPrintTo_Tests, NestedContainers) {
   JsonArray nested2 = object.createNestedArray("key2");
   nested2.add(2);
 
-  outputMustBe("{\r\n"
+  outputMustBe(
-               "  \"key1\": {\r\n"
+      "{\r\n"
-               "    \"a\": 1\r\n"
+      "  \"key1\": {\r\n"
-               "  },\r\n"
+      "    \"a\": 1\r\n"
-               "  \"key2\": [\r\n"
+      "  },\r\n"
-               "    2\r\n"
+      "  \"key2\": [\r\n"
-               "  ]\r\n"
+      "    2\r\n"
-               "}");
+      "  ]\r\n"
+      "}");
 }

test/JsonObject_Serialization_Tests.cpp

@@ -7,7 +7,7 @@
 using namespace ArduinoJson;
 
 class JsonObject_Serialization_Tests : public testing::Test {
-protected:
+ protected:
   virtual void SetUp() { object = json.createObject(); }
 
   void outputMustBe(const char *expected) {

test/JsonParser_Array_Tests.cpp

@@ -5,7 +5,7 @@
 using namespace ArduinoJson;
 
 class JsonParser_Array_Tests : public testing::Test {
-protected:
+ protected:
   void whenInputIs(const char *json) {
     strcpy(_jsonString, json);
     _array = _jsonBuffer.parseArray(_jsonString);
@@ -20,15 +20,18 @@ protected:
 
   void sizeMustBe(int expected) { EXPECT_EQ(expected, _array.size()); }
 
-  template <typename T> void firstElementMustBe(T expected) {
+  template <typename T>
+  void firstElementMustBe(T expected) {
     elementAtIndexMustBe(0, expected);
   }
 
-  template <typename T> void secondElementMustBe(T expected) {
+  template <typename T>
+  void secondElementMustBe(T expected) {
     elementAtIndexMustBe(1, expected);
   }
 
-  template <typename T> void elementAtIndexMustBe(int index, T expected) {
+  template <typename T>
+  void elementAtIndexMustBe(int index, T expected) {
     EXPECT_EQ(expected, _array[index].as<T>());
   }
 

test/JsonParser_Object_Tests.cpp

@@ -5,7 +5,7 @@
 using namespace ArduinoJson;
 
 class JsonParser_Object_Test : public testing::Test {
-protected:
+ protected:
   void whenInputIs(const char *jsonString) {
     strcpy(_jsonString, jsonString);
     _object = _jsonBuffer.parseObject(_jsonString);
@@ -21,11 +21,12 @@ protected:
     EXPECT_STREQ(expected, _object[key].as<const char *>());
   }
 
-  template <typename T> void keyMustHaveValue(const char *key, T expected) {
+  template <typename T>
+  void keyMustHaveValue(const char *key, T expected) {
     EXPECT_EQ(expected, _object[key].as<T>());
   }
 
-private:
+ private:
   StaticJsonBuffer<10> _jsonBuffer;
   JsonObject _object;
   char _jsonString[256];

test/JsonValueTests.cpp

@@ -5,7 +5,7 @@
 using namespace ArduinoJson;
 
 class JsonValueTests : public ::testing::Test {
-protected:
+ protected:
   virtual void SetUp() {
     jsonValue1 = json.createValue();
     jsonValue2 = json.createValue();

test/QuotedString_ExtractFrom_Tests.cpp

@@ -4,7 +4,7 @@
 using namespace ArduinoJson::Internals;
 
 class QuotedString_ExtractFrom_Tests : public testing::Test {
-protected:
+ protected:
   void whenInputIs(const char *json) {
     strcpy(_jsonString, json);
     _result = QuotedString::extractFrom(_jsonString, &_trailing);
@@ -16,7 +16,7 @@ protected:
     EXPECT_STREQ(expected, _trailing);
   }
 
-private:
+ private:
   char _jsonString[256];
   char *_result;
   char *_trailing;

test/QuotedString_PrintTo_Tests.cpp

@@ -6,7 +6,7 @@
 using namespace ArduinoJson::Internals;
 
 class QuotedString_PrintTo_Tests : public testing::Test {
-protected:
+ protected:
   void whenInputIs(const char *input) {
     StringBuilder sb(buffer, sizeof(buffer));
     returnValue = QuotedString::printTo(input, &sb);
@@ -17,7 +17,7 @@ protected:
     EXPECT_EQ(strlen(expected), returnValue);
   }
 
-private:
+ private:
   char buffer[1024];
   size_t returnValue;
 };
@@ -44,7 +44,7 @@ TEST_F(QuotedString_PrintTo_Tests, ReverseSolidus) {
 
 TEST_F(QuotedString_PrintTo_Tests, Solidus) {
   whenInputIs("/");
-  outputMustBe("\"/\""); // but the JSON format allows \/
+  outputMustBe("\"/\"");  // but the JSON format allows \/
 }
 
 TEST_F(QuotedString_PrintTo_Tests, Backspace) {

test/StringBuilderTests.cpp

@@ -4,7 +4,7 @@
 using namespace ArduinoJson::Internals;
 
 class StringBuilderTests : public testing::Test {
-protected:
+ protected:
   virtual void SetUp() { sb = new StringBuilder(buffer, sizeof(buffer)); }
 
   void print(const char *value) { returnValue = sb->print(value); }
@@ -13,7 +13,7 @@ protected:
 
   void resultMustBe(size_t expected) { EXPECT_EQ(expected, returnValue); }
 
-private:
+ private:
   char buffer[20];
   Print *sb;
   size_t returnValue;