Renamed JsonSink::append() into write() to match Arduino's Print class

JsonGeneratorTests/JsonArray.h

@@ -41,19 +41,19 @@ private:
     {
         size_t n = 0;
         
-        n += sb.append("[");
+        n += sb.write("[");
 
         for (int i = 0; i < itemCount; i++)
         {
             if (i > 0)
             {
-                n += sb.append(",");
+                n += sb.write(",");
             }
 
             n += items[i].writeTo(sb);
         }
 
-        n += sb.append("]");
+        n += sb.write("]");
 
         return n;
     }

JsonGeneratorTests/JsonHashTable.h

@@ -49,7 +49,7 @@ private:
     {
         size_t n = 0;
 
-        n += sink.append('{');
+        n += sink.write('{');
 
         for (int i = 0; i < itemCount; i++)
         {
@@ -57,15 +57,15 @@ private:
 
             if (i > 0)
             {
-                n += sink.append(',');
+                n += sink.write(',');
             }
 
             n += key.writeTo(sink);
-            n += sink.append(':');
+            n += sink.write(':');
             n += items[i].value.writeTo(sink);
         }
 
-        n += sink.append('}');
+        n += sink.write('}');
 
         return n;
     }

JsonGeneratorTests/JsonSink.h

@@ -9,14 +9,14 @@ class JsonSink
 {
 public:
 
-    virtual size_t append(char c) = 0;
+    virtual size_t write(char c) = 0;
     
-    size_t append(const char* s)
+    size_t write(const char* s)
     {
         size_t n = 0;
         while (*s)
         {
-            n += append(*s++);
+            n += write(*s++);
         }
         return n;
     }

JsonGeneratorTests/JsonValue.cpp

@@ -10,7 +10,7 @@
 
 size_t JsonValue::writeBooleanTo(JsonSink& sb)
 {
-    return sb.append(content.boolean ? "true" : "false");
+    return sb.write(content.boolean ? "true" : "false");
 }
 
 size_t JsonValue::writeNumberTo(JsonSink& sb)
@@ -19,7 +19,7 @@ size_t JsonValue::writeNumberTo(JsonSink& sb)
 
     _snprintf(tmp, sizeof(tmp), "%lg", content.number);
 
-    return sb.append(tmp);
+    return sb.write(tmp);
 }
 
 size_t JsonValue::writeObjectTo(JsonSink& sink)
@@ -27,7 +27,7 @@ size_t JsonValue::writeObjectTo(JsonSink& sink)
     if (content.object)
         return ((JsonObjectBase*)content.object)->writeTo(sink);
     else
-        return sink.append("null");
+        return sink.write("null");
 }
 
 size_t JsonValue::writeStringTo(JsonSink& sink)
@@ -36,54 +36,54 @@ size_t JsonValue::writeStringTo(JsonSink& sink)
 
     if (!s)
     {
-        return sink.append("null");
+        return sink.write("null");
     }
 
     size_t n = 0;
 
-    n += sink.append('\"');
+    n += sink.write('\"');
 
     while (*s)
     {
         switch (*s)
         {
         case '"':
-            n += sink.append("\\\"");
+            n += sink.write("\\\"");
             break;
 
         case '\\':
-            n += sink.append("\\\\");
+            n += sink.write("\\\\");
             break;
 
         case '\b':
-            n += sink.append("\\b");
+            n += sink.write("\\b");
             break;
 
         case '\f':
-            n += sink.append("\\f");
+            n += sink.write("\\f");
             break;
 
         case '\n':
-            n += sink.append("\\n");
+            n += sink.write("\\n");
             break;
 
         case '\r':
-            n += sink.append("\\r");
+            n += sink.write("\\r");
             break;
 
         case '\t':
-            n += sink.append("\\t");
+            n += sink.write("\\t");
             break;
 
         default:
-            n += sink.append(*s);
+            n += sink.write(*s);
             break;
         }
 
         s++;
     }
 
-    n += sink.append('\"');
+    n += sink.write('\"');
 
     return n;
 }

JsonGeneratorTests/JsonValueTests.cpp

@@ -26,7 +26,7 @@ namespace JsonGeneratorTests
 
         TEST_METHOD(Null)
         {
-            append((char*)0);
+            write((char*)0);
 
             assertReturns(4);
             assertResultIs("null");
@@ -34,7 +34,7 @@ namespace JsonGeneratorTests
 
         TEST_METHOD(EmptyString)
         {
-            append("");
+            write("");
 
             assertReturns(2);
             assertResultIs("\"\"");
@@ -42,17 +42,17 @@ namespace JsonGeneratorTests
 
         TEST_METHOD(OneString)
         {
-            append("ABCD");
+            write("ABCD");
             assertReturns(6);
             assertResultIs("\"ABCD\"");
         }
 
         TEST_METHOD(OneTwoStrings)
         {
-            append("ABCD");
+            write("ABCD");
             assertReturns(6);
 
-            append("EFGH");
+            write("EFGH");
             assertReturns(6);
             
             assertResultIs("\"ABCD\"\"EFGH\"");
@@ -60,31 +60,31 @@ namespace JsonGeneratorTests
 
         TEST_METHOD(OverCapacity)
         {
-            append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+            write("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
             assertReturns(19);
             assertResultIs("\"ABCDEFGHIJKLMNOPQR");
 
-            append("ABC");
+            write("ABC");
             assertReturns(0);
             assertResultIs("\"ABCDEFGHIJKLMNOPQR");
         }
 
         TEST_METHOD(SpecialChars)
         {
-            append("\\\"\b\f\n\r\t");
+            write("\\\"\b\f\n\r\t");
             assertReturns(16);
             assertResultIs("\"\\\\\\\"\\b\\f\\n\\r\\t\"");
         }
 
         TEST_METHOD(Number)
         {
-            append(3.14);
+            write(3.14);
             assertReturns(4);
             assertResultIs("3.14");
         }
 
         template<typename T>
-        void append(T value)
+        void write(T value)
         {
             returnValue = JsonValue(value).writeTo(*sb);
         }

JsonGeneratorTests/StringBuilder.cpp

@@ -5,7 +5,7 @@
 
 #include "StringBuilder.h"
 
-size_t StringBuilder::append(char c)
+size_t StringBuilder::write(char c)
 {
     if (length >= capacity) return 0;
 

JsonGeneratorTests/StringBuilder.h

@@ -16,8 +16,7 @@ public:
         buffer[0] = 0;
     }
 
-    virtual size_t append(char c);
-    size_t append(const char* c);
+    virtual size_t write(char c);
 
 private:
     char* buffer;