18653349747

Committed 20 Oct 2025 12:56PM UTC coverage: 99.34% (-0.08%) from 99.417%

Build # 18653349747

Build Type

push

github

Committed by

bblanchon

Commit Message

Return `bool` from all built-in `toJson` converters

Run Details

104 of 108 new or added lines in 8 files covered. (96.3%)

3 existing lines in 2 files now uncovered.

3916 of 3942 relevant lines covered (99.34%)

10349.1 hits per line

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

98.44

/src/ArduinoJson/MsgPack/MsgPackBinary.hpp

#pragma once

#include <ArduinoJson/Variant/Converter.hpp>

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 bool toJson(MsgPackBinary src, JsonVariant dst) {
    auto data = VariantAttorney::getData(dst);
    if (!data)
      return false;

    auto resources = getResourceManager(dst);
    detail::VariantImpl::clear(data, resources);

    if (!src.data())
      return true;

    size_t headerSize = src.size() >= 0x10000 ? 5 : src.size() >= 0x100 ? 3 : 2;

    auto str = resources->createString(src.size() + headerSize);
    if (!str)
      return false;

    resources->saveString(str);
    auto ptr = reinterpret_cast<uint8_t*>(str->data);
    switch (headerSize) {
      case 2:
        ptr[0] = uint8_t(0xc4);
        ptr[1] = uint8_t(src.size() & 0xff);
        break;
      case 3:
        ptr[0] = uint8_t(0xc5);
        ptr[1] = uint8_t(src.size() >> 8 & 0xff);
        ptr[2] = uint8_t(src.size() & 0xff);
        break;
      case 5:
        ptr[0] = uint8_t(0xc6);
        ptr[1] = uint8_t(src.size() >> 24 & 0xff);
        ptr[2] = uint8_t(src.size() >> 16 & 0xff);
        ptr[3] = uint8_t(src.size() >> 8 & 0xff);
        ptr[4] = uint8_t(src.size() & 0xff);
        break;
      default:
        ARDUINOJSON_ASSERT(false);
    }
    memcpy(ptr + headerSize, src.data(), src.size());
    data->setRawString(str);
    return true;
  }

  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 {};
  }

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

ARDUINOJSON_END_PUBLIC_NAMESPACE

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

bblanchon / ArduinoJson / 18653349747

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