8882965000

Committed 29 Apr 2024 05:38PM UTC coverage: 99.521%. Remained the same

Build # 8882965000

Build Type

push

github

Committed by

bblanchon

Commit Message

Implement MsgPackBinary using raw strings and converters

Run Details

77 of 79 new or added lines in 3 files covered. (97.47%)

6 existing lines in 2 files now uncovered.

3740 of 3758 relevant lines covered (99.52%)

14058.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.39

/src/ArduinoJson/MsgPack/MsgPackBinary.hpp

#pragma once

ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE

class MsgPackBinary {
 public:
  MsgPackBinary() : data_(nullptr), size_(0) {}
  explicit MsgPackBinary(const void* c, size_t size) : data_(c), size_(size) {}

  const void* data() const {
    return data_;
  }

  size_t size() const {
    return size_;
  }

 private:
  const void* data_;
  size_t size_;
};

template <>
struct Converter<MsgPackBinary> : private detail::VariantAttorney {
  static void toJson(MsgPackBinary src, JsonVariant dst) {
    auto data = VariantAttorney::getData(dst);
    if (!data)
      return;
    auto resources = getResourceManager(dst);
    if (src.data()) {
      size_t headerSize = src.size() >= 0x10000 ? 5
                          : src.size() >= 0x100 ? 3
                                                : 2;
      auto str = resources->createString(src.size() + headerSize);
      auto ptr = str->data;
      if (str) {
        switch (headerSize) {
          case 2:
            ptr[0] = static_cast<char>(0xc4);
            ptr[1] = static_cast<char>(src.size());
            break;
          case 3:
            ptr[0] = static_cast<char>(0xc5);
            ptr[1] = static_cast<char>(src.size() >> 8);
            ptr[2] = static_cast<char>(src.size());
            break;
          case 5:
            ptr[0] = static_cast<char>(0xc6);
            ptr[1] = static_cast<char>(src.size() >> 24);
            ptr[2] = static_cast<char>(src.size() >> 16);
            ptr[3] = static_cast<char>(src.size() >> 8);
            ptr[4] = static_cast<char>(src.size());
            break;
        }
        memcpy(ptr + headerSize, src.data(), src.size());
        data->setRawString(str);
        return;
      }
    }
    data->setNull();
  }

  static MsgPackBinary fromJson(JsonVariantConst src) {
    auto data = getData(src);
    if (!data)
      return {};
    auto rawstr = data->asRawString();
    auto p = reinterpret_cast<const uint8_t*>(rawstr.c_str());
    auto n = rawstr.size();
    if (n >= 2 && p[0] == 0xc4) {  // bin 8
      size_t size = p[1];
      if (size + 2 == n)
        return MsgPackBinary(p + 2, size);
    } else if (n >= 3 && p[0] == 0xc5) {  // bin 16
      size_t size = size_t(p[1] << 8) | p[2];
      if (size + 3 == n)
        return MsgPackBinary(p + 3, size);
    } else if (n >= 5 && p[0] == 0xc6) {  // bin 32
      size_t size =
          size_t(p[1] << 24) | size_t(p[2] << 16) | size_t(p[3] << 8) | p[4];
      if (size + 5 == n)
        return MsgPackBinary(p + 5, size);
    }
    return {};  // TODO: not covered by tests
  }

  static bool checkJson(JsonVariantConst src) {
    return fromJson(src).data() != nullptr;
  }
};

ARDUINOJSON_END_PUBLIC_NAMESPACE

1	#pragma once
2
3	ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
4
5	class MsgPackBinary {
6	public:
7	MsgPackBinary() : data_(nullptr), size_(0) {}	2✔
8	explicit MsgPackBinary(const void* c, size_t size) : data_(c), size_(size) {}	21✔
9
10	const void* data() const {	36✔
11	return data_;	36✔
12	}
13
14	size_t size() const {	78✔
15	return size_;	78✔
16	}
17
18	private:
19	const void* data_;
20	size_t size_;
21	};
22
23	template <>
24	struct Converter<MsgPackBinary> : private detail::VariantAttorney {
25	static void toJson(MsgPackBinary src, JsonVariant dst) {	15✔
26	auto data = VariantAttorney::getData(dst);	15✔
27	if (!data)	15✔
28	return;	1✔
29	auto resources = getResourceManager(dst);	14✔
30	if (src.data()) {	14✔
31	size_t headerSize = src.size() >= 0x10000 ? 5	26✔
32	: src.size() >= 0x100 ? 3	12✔
33	: 2;	14✔
34	auto str = resources->createString(src.size() + headerSize);	14✔
35	auto ptr = str->data;	14✔
36	if (str) {	14✔
37	switch (headerSize) {	12✔
38	case 2:	8✔
39	ptr[0] = static_cast<char>(0xc4);	8✔
40	ptr[1] = static_cast<char>(src.size());	8✔
41	break;	8✔
42	case 3:	2✔
43	ptr[0] = static_cast<char>(0xc5);	2✔
44	ptr[1] = static_cast<char>(src.size() >> 8);	2✔
45	ptr[2] = static_cast<char>(src.size());	2✔
46	break;	2✔
47	case 5:	2✔
48	ptr[0] = static_cast<char>(0xc6);	2✔
49	ptr[1] = static_cast<char>(src.size() >> 24);	2✔
50	ptr[2] = static_cast<char>(src.size() >> 16);	2✔
51	ptr[3] = static_cast<char>(src.size() >> 8);	2✔
52	ptr[4] = static_cast<char>(src.size());	2✔
53	break;	2✔
54	}
55	memcpy(ptr + headerSize, src.data(), src.size());	12✔
56	data->setRawString(str);	12✔
57	return;	12✔
58	}
59	}
60	data->setNull();	2✔
61	}
62
63	static MsgPackBinary fromJson(JsonVariantConst src) {	8✔
64	auto data = getData(src);	8✔
65	if (!data)	8✔
66	return {};	2✔
67	auto rawstr = data->asRawString();	6✔
68	auto p = reinterpret_cast<const uint8_t*>(rawstr.c_str());	6✔
69	auto n = rawstr.size();	6✔
70	if (n >= 2 && p[0] == 0xc4) { // bin 8	6✔
71	size_t size = p[1];	2✔
72	if (size + 2 == n)	2✔
73	return MsgPackBinary(p + 2, size);	2✔
74	} else if (n >= 3 && p[0] == 0xc5) { // bin 16	4✔
75	size_t size = size_t(p[1] << 8) \| p[2];	2✔
76	if (size + 3 == n)	2✔
77	return MsgPackBinary(p + 3, size);	2✔
78	} else if (n >= 5 && p[0] == 0xc6) { // bin 32	2✔
79	size_t size =	2✔
80	size_t(p[1] << 24) \| size_t(p[2] << 16) \| size_t(p[3] << 8) \| p[4];	2✔
81	if (size + 5 == n)	2✔
82	return MsgPackBinary(p + 5, size);	2✔
83	}
NEW 84	return {}; // TODO: not covered by tests	×
85	}
86
87	static bool checkJson(JsonVariantConst src) {	3✔
88	return fromJson(src).data() != nullptr;	3✔
89	}
90	};
91
92	ARDUINOJSON_END_PUBLIC_NAMESPACE

bblanchon / ArduinoJson / 8882965000

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous