MsgPack bin8/bin16/bin32 support

extras/tests/MixedConfiguration/CMakeLists.txt

@@ -22,6 +22,7 @@ add_executable(MixedConfigurationTests
 	use_double_1.cpp
 	use_long_long_0.cpp
 	use_long_long_1.cpp
+	string_length_size_4.cpp
 )
 
 set_target_properties(MixedConfigurationTests PROPERTIES UNITY_BUILD OFF)

extras/tests/MsgPackDeserializer/deserializeVariant.cpp

@@ -3,6 +3,7 @@
 // MIT License
 
 #include <ArduinoJson.h>
+#include <array>
 #include <catch.hpp>
 
 #include "Allocators.hpp"
@@ -139,6 +140,36 @@ TEST_CASE("deserialize MsgPack value") {
   SECTION("str 32") {
     checkValue<std::string>("\xdb\x00\x00\x00\x05hello", std::string("hello"));
   }
+
+  SECTION("bin 8") {
+    JsonDocument doc;
+
+    DeserializationError error = deserializeMsgPack(doc, "\xc4\x01\x05");
+
+    REQUIRE(error == DeserializationError::Ok);
+    REQUIRE(doc.is<MsgPackBinary>());
+    auto binary = doc.as<MsgPackBinary>();
+    REQUIRE(binary.size() == 1);
+    REQUIRE(binary.data() != nullptr);
+    REQUIRE(reinterpret_cast<const char*>(binary.data())[0] == 5);
+  }
+
+  SECTION("bin 16") {
+    JsonDocument doc;
+
+    auto array = std::array<char, 0x100>({5});
+    auto input = std::string("\xc5\x01\x00", 3) +
+                 std::string(array.data(), array.size());
+
+    DeserializationError error = deserializeMsgPack(doc, input);
+
+    REQUIRE(error == DeserializationError::Ok);
+    REQUIRE(doc.is<MsgPackBinary>());
+    auto binary = doc.as<MsgPackBinary>();
+    REQUIRE(binary.size() == 0x100);
+    REQUIRE(binary.data() != nullptr);
+    REQUIRE(reinterpret_cast<const char*>(binary.data())[0] == 5);
+  }
 }
 
 TEST_CASE("deserializeMsgPack() under memory constaints") {

extras/tests/MsgPackSerializer/serializeVariant.cpp

@@ -3,6 +3,7 @@
 // MIT License
 
 #include <ArduinoJson.h>
+#include <array>
 #include <catch.hpp>
 
 template <typename T>
@@ -146,6 +147,19 @@ TEST_CASE("serialize MsgPack value") {
     checkVariant(serialized("\xDB\x00\x01\x00\x00", 5), "\xDB\x00\x01\x00\x00");
   }
 
+  SECTION("bin 8") {
+    static const auto bin8 = std::array<char, 4>({1, 2, 3, 4});
+    checkVariant(MsgPackBinary(bin8.data(), bin8.size()),
+                 "\xC4\x04\x01\x02\x03\x04");
+  }
+
+  SECTION("bin 16") {
+    static const auto bin16 = std::array<char, 0x100>({1, 2, 3, 4});
+    std::string bin16string(bin16.data(), bin16.size());
+    checkVariant(MsgPackBinary(bin16.data(), bin16.size()),
+                 std::string("\xC5\x01\x00", 3) + bin16string);
+  }
+
   SECTION("serialize round double as integer") {  // Issue #1718
     checkVariant(-32768.0, "\xD1\x80\x00");
     checkVariant(-129.0, "\xD1\xFF\x7F");

src/ArduinoJson/Json/JsonSerializer.hpp

@@ -81,6 +81,10 @@ class JsonSerializer : public VariantDataVisitor<size_t> {
     return bytesWritten();
   }
 
+  size_t visit(MsgPackBinary) {
+    return visit(nullptr);
+  }
+
   size_t visit(JsonInteger value) {
     formatter_.writeInteger(value);
     return bytesWritten();

src/ArduinoJson/MsgPack/MsgPackBinary.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
+
+class MsgPackBinary {
+ public:
+  explicit MsgPackBinary(const void* c, size_t size) : data_(c), size_(size) {}
+  operator const void*() const {
+    return data_;
+  }
+
+  const void* data() const {
+    return data_;
+  }
+
+  size_t size() const {
+    return size_;
+  }
+
+ private:
+  const void* data_;
+  size_t size_;
+};
+
+ARDUINOJSON_END_PUBLIC_NAMESPACE

src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp

@@ -69,14 +69,23 @@ class MsgPackDeserializer {
           variant->setBoolean(true);
         return DeserializationError::Ok;
 
-      case 0xc4:  // bin 8 (not supported)
-        return skipString<uint8_t>();
+      case 0xc4:
+        if (allowValue)
+          return readBinary<uint8_t>(variant);
+        else
+          return skipString<uint8_t>();
 
-      case 0xc5:  // bin 16 (not supported)
-        return skipString<uint16_t>();
+      case 0xc5:
+        if (allowValue)
+          return readBinary<uint16_t>(variant);
+        else
+          return skipString<uint16_t>();
 
-      case 0xc6:  // bin 32 (not supported)
-        return skipString<uint32_t>();
+      case 0xc6:
+        if (allowValue)
+          return readBinary<uint32_t>(variant);
+        else
+          return skipString<uint32_t>();
 
       case 0xc7:  // ext 8 (not supported)
         return skipExt<uint8_t>();
@@ -394,6 +403,29 @@ class MsgPackDeserializer {
     return DeserializationError::Ok;
   }
 
+  template <typename T>
+  DeserializationError::Code readBinary(VariantData* variant) {
+    DeserializationError::Code err;
+    T size;
+
+    err = readInteger(size);
+    if (err)
+      return err;
+
+    return readBinary(variant, size);
+  }
+
+  DeserializationError::Code readBinary(VariantData* variant, size_t n) {
+    DeserializationError::Code err;
+
+    err = readString(n);
+    if (err)
+      return err;
+
+    variant->setBinary(stringBuilder_.save());
+    return DeserializationError::Ok;
+  }
+
   template <typename TSize, typename TFilter>
   DeserializationError::Code readArray(
       VariantData* variant, TFilter filter,

src/ArduinoJson/MsgPack/MsgPackSerializer.hpp

@@ -123,6 +123,21 @@ class MsgPackSerializer : public VariantDataVisitor<size_t> {
     return bytesWritten();
   }
 
+  size_t visit(MsgPackBinary value) {
+    if (value.size() <= 0xFF) {
+      writeByte(0xC4);
+      writeInteger(uint8_t(value.size()));
+    } else if (value.size() <= 0xFFFF) {
+      writeByte(0xC5);
+      writeInteger(uint16_t(value.size()));
+    } else {
+      writeByte(0xC6);
+      writeInteger(uint32_t(value.size()));
+    }
+    writeBytes(reinterpret_cast<const uint8_t*>(value.data()), value.size());
+    return bytesWritten();
+  }
+
   size_t visit(JsonInteger value) {
     if (value > 0) {
       visit(static_cast<JsonUInt>(value));

src/ArduinoJson/Variant/ConverterImpl.hpp

@@ -192,6 +192,21 @@ struct Converter<SerializedValue<T>> : private detail::VariantAttorney {
   }
 };
 
+template <>
+struct Converter<MsgPackBinary> : private detail::VariantAttorney {
+  static void toJson(MsgPackBinary src, JsonVariant dst) {
+    detail::VariantData::setBinary(getData(dst), src, getResourceManager(dst));
+  }
+  static MsgPackBinary fromJson(JsonVariantConst src) {
+    auto data = getData(src);
+    return data->asBinary();
+  }
+  static bool checkJson(JsonVariantConst src) {
+    auto data = getData(src);
+    return data && data->isBinary();
+  }
+};
+
 template <>
 struct Converter<detail::nullptr_t> : private detail::VariantAttorney {
   static void toJson(detail::nullptr_t, JsonVariant dst) {

src/ArduinoJson/Variant/VariantCompare.hpp

@@ -164,6 +164,12 @@ struct VariantComparer : ComparerBase {
     return reverseResult(comparer);
   }
 
+  CompareResult visit(MsgPackBinary value) {
+    RawComparer comparer(
+        RawString(reinterpret_cast<const char*>(value.data()), value.size()));
+    return reverseResult(comparer);
+  }
+
   CompareResult visit(JsonInteger lhs) {
     Comparer<JsonInteger> comparer(lhs);
     return reverseResult(comparer);

src/ArduinoJson/Variant/VariantContent.hpp

@@ -21,6 +21,7 @@ enum {
   VALUE_IS_RAW_STRING = 0x03,
   VALUE_IS_LINKED_STRING = 0x04,
   VALUE_IS_OWNED_STRING = 0x05,
+  VALUE_IS_BINARY = 0x07,
 
   // CAUTION: no OWNED_VALUE_BIT below
 

src/ArduinoJson/Variant/VariantData.hpp

@@ -6,6 +6,7 @@
 
 #include <ArduinoJson/Memory/StringNode.hpp>
 #include <ArduinoJson/Misc/SerializedValue.hpp>
+#include <ArduinoJson/MsgPack/MsgPackBinary.hpp>
 #include <ArduinoJson/Numbers/convertNumber.hpp>
 #include <ArduinoJson/Strings/JsonString.hpp>
 #include <ArduinoJson/Strings/StringAdapters.hpp>
@@ -48,6 +49,10 @@ class VariantData {
         return visit.visit(RawString(content_.asOwnedString->data,
                                      content_.asOwnedString->length));
 
+      case VALUE_IS_BINARY:
+        return visit.visit(MsgPackBinary(content_.asOwnedString->data,
+                                         content_.asOwnedString->length));
+
       case VALUE_IS_SIGNED_INTEGER:
         return visit.visit(content_.asSignedInteger);
 
@@ -185,6 +190,16 @@ class VariantData {
     }
   }
 
+  MsgPackBinary asBinary() const {
+    switch (type()) {
+      case VALUE_IS_BINARY:
+        return MsgPackBinary(content_.asOwnedString->data,
+                             content_.asOwnedString->length);
+      default:
+        return MsgPackBinary(nullptr, 0);
+    }
+  }
+
   VariantData* getElement(size_t index,
                           const ResourceManager* resources) const {
     return ArrayData::getElement(asArray(), index, resources);
@@ -274,6 +289,10 @@ class VariantData {
     return type() == VALUE_IS_LINKED_STRING || type() == VALUE_IS_OWNED_STRING;
   }
 
+  bool isBinary() const {
+    return type() == VALUE_IS_BINARY;
+  }
+
   size_t nesting(const ResourceManager* resources) const {
     auto collection = asCollection();
     if (collection)
@@ -394,6 +413,28 @@ class VariantData {
     var->setRawString(value, resources);
   }
 
+  void setBinary(StringNode* s) {
+    ARDUINOJSON_ASSERT(s);
+    setType(VALUE_IS_BINARY);
+    content_.asOwnedString = s;
+  }
+
+  void setBinary(MsgPackBinary value, ResourceManager* resources) {
+    auto dup = resources->saveString(
+        adaptString(reinterpret_cast<const char*>(value.data()), value.size()));
+    if (dup)
+      setBinary(dup);
+    else
+      setNull();
+  }
+
+  static void setBinary(VariantData* var, MsgPackBinary value,
+                        ResourceManager* resources) {
+    if (!var)
+      return;
+    var->setBinary(value, resources);
+  }
+
   template <typename TAdaptedString>
   void setString(TAdaptedString value, ResourceManager* resources) {
     setNull(resources);