Disabled drum menus when drums not enabled. Replaced all strcpy(),strncpy(),strcat(),strncat() against strlcpy()/strlcat.dev
parent
70f5c12484
commit
a0d3fee52f
|
Before Width: | Height: | Size: 32 KiB |
@ -0,0 +1,72 @@ |
||||
// ArduinoJson - https://arduinojson.org
|
||||
// Copyright © 2014-2022, Benoit BLANCHON
|
||||
// MIT License
|
||||
|
||||
#include <ArduinoJson.h> |
||||
#include <stdint.h> |
||||
#include <catch.hpp> |
||||
|
||||
#include <string> |
||||
#include <vector> |
||||
|
||||
namespace ARDUINOJSON_NAMESPACE { |
||||
template <typename T> |
||||
struct Converter<std::vector<T> > { |
||||
static void toJson(const std::vector<T>& src, JsonVariant dst) { |
||||
JsonArray array = dst.to<JsonArray>(); |
||||
for (T item : src) |
||||
array.add(item); |
||||
} |
||||
|
||||
static std::vector<T> fromJson(JsonVariantConst src) { |
||||
std::vector<T> dst; |
||||
for (T item : src.as<JsonArrayConst>()) |
||||
dst.push_back(item); |
||||
return dst; |
||||
} |
||||
|
||||
static bool checkJson(JsonVariantConst src) { |
||||
JsonArrayConst array = src; |
||||
bool result = array; |
||||
for (JsonVariantConst item : array) { |
||||
if (!result) |
||||
break; |
||||
result = item.is<T>(); |
||||
} |
||||
return result; |
||||
} |
||||
}; |
||||
} // namespace ARDUINOJSON_NAMESPACE
|
||||
|
||||
TEST_CASE("vector<int>") { |
||||
SECTION("toJson") { |
||||
std::vector<int> v = {1, 2}; |
||||
|
||||
StaticJsonDocument<128> doc; |
||||
doc.set(v); |
||||
REQUIRE(doc.as<std::string>() == "[1,2]"); |
||||
} |
||||
|
||||
SECTION("fromJson") { |
||||
StaticJsonDocument<128> doc; |
||||
doc.add(1); |
||||
doc.add(2); |
||||
|
||||
auto v = doc.as<std::vector<int> >(); |
||||
REQUIRE(v.size() == 2); |
||||
CHECK(v[0] == 1); |
||||
CHECK(v[1] == 2); |
||||
} |
||||
|
||||
SECTION("checkJson") { |
||||
StaticJsonDocument<128> doc; |
||||
CHECK(doc.is<std::vector<int> >() == false); |
||||
|
||||
doc.add(1); |
||||
doc.add(2); |
||||
CHECK(doc.is<std::vector<int> >() == true); |
||||
|
||||
doc.add("foo"); |
||||
CHECK(doc.is<std::vector<int> >() == false); |
||||
} |
||||
} |
||||
@ -0,0 +1,512 @@ |
||||
// ArduinoJson - https://arduinojson.org
|
||||
// Copyright © 2014-2022, Benoit BLANCHON
|
||||
// MIT License
|
||||
|
||||
#include <ArduinoJson.h> |
||||
#include <catch.hpp> |
||||
|
||||
TEST_CASE("Compare JsonArray with JsonArray") { |
||||
StaticJsonDocument<256> doc; |
||||
|
||||
SECTION("Compare with unbound") { |
||||
JsonArray array = doc.to<JsonArray>(); |
||||
array.add(1); |
||||
array.add("hello"); |
||||
JsonArray unbound; |
||||
|
||||
CHECK(array != unbound); |
||||
CHECK_FALSE(array == unbound); |
||||
CHECK_FALSE(array <= unbound); |
||||
CHECK_FALSE(array >= unbound); |
||||
CHECK_FALSE(array > unbound); |
||||
CHECK_FALSE(array < unbound); |
||||
|
||||
CHECK(unbound != array); |
||||
CHECK_FALSE(unbound == array); |
||||
CHECK_FALSE(unbound <= array); |
||||
CHECK_FALSE(unbound >= array); |
||||
CHECK_FALSE(unbound > array); |
||||
CHECK_FALSE(unbound < array); |
||||
} |
||||
|
||||
SECTION("Compare with self") { |
||||
JsonArray array = doc.to<JsonArray>(); |
||||
array.add(1); |
||||
array.add("hello"); |
||||
|
||||
CHECK(array == array); |
||||
CHECK(array <= array); |
||||
CHECK(array >= array); |
||||
CHECK_FALSE(array != array); |
||||
CHECK_FALSE(array > array); |
||||
CHECK_FALSE(array < array); |
||||
} |
||||
|
||||
SECTION("Compare with identical array") { |
||||
JsonArray array1 = doc.createNestedArray(); |
||||
array1.add(1); |
||||
array1.add("hello"); |
||||
array1.createNestedObject(); |
||||
|
||||
JsonArray array2 = doc.createNestedArray(); |
||||
array2.add(1); |
||||
array2.add("hello"); |
||||
array2.createNestedObject(); |
||||
|
||||
CHECK(array1 == array2); |
||||
CHECK(array1 <= array2); |
||||
CHECK(array1 >= array2); |
||||
CHECK_FALSE(array1 != array2); |
||||
CHECK_FALSE(array1 > array2); |
||||
CHECK_FALSE(array1 < array2); |
||||
} |
||||
|
||||
SECTION("Compare with different array") { |
||||
JsonArray array1 = doc.createNestedArray(); |
||||
array1.add(1); |
||||
array1.add("hello1"); |
||||
array1.createNestedObject(); |
||||
|
||||
JsonArray array2 = doc.createNestedArray(); |
||||
array2.add(1); |
||||
array2.add("hello2"); |
||||
array2.createNestedObject(); |
||||
|
||||
CHECK(array1 != array2); |
||||
CHECK_FALSE(array1 == array2); |
||||
CHECK_FALSE(array1 > array2); |
||||
CHECK_FALSE(array1 < array2); |
||||
CHECK_FALSE(array1 <= array2); |
||||
CHECK_FALSE(array1 >= array2); |
||||
} |
||||
} |
||||
|
||||
TEST_CASE("Compare JsonArray with JsonVariant") { |
||||
StaticJsonDocument<256> doc; |
||||
|
||||
SECTION("Compare with self") { |
||||
JsonArray array = doc.to<JsonArray>(); |
||||
array.add(1); |
||||
array.add("hello"); |
||||
|
||||
JsonVariant variant = array; |
||||
|
||||
CHECK(array == variant); |
||||
CHECK(array <= variant); |
||||
CHECK(array >= variant); |
||||
CHECK_FALSE(array != variant); |
||||
CHECK_FALSE(array > variant); |
||||
CHECK_FALSE(array < variant); |
||||
|
||||
CHECK(variant == array); |
||||
CHECK(variant <= array); |
||||
CHECK(variant >= array); |
||||
CHECK_FALSE(variant != array); |
||||
CHECK_FALSE(variant > array); |
||||
CHECK_FALSE(variant < array); |
||||
} |
||||
|
||||
SECTION("Compare with identical array") { |
||||
JsonArray array = doc.createNestedArray(); |
||||
array.add(1); |
||||
array.add("hello"); |
||||
array.createNestedObject(); |
||||
|
||||
JsonVariant variant = doc.createNestedArray(); |
||||
variant.add(1); |
||||
variant.add("hello"); |
||||
variant.createNestedObject(); |
||||
|
||||
CHECK(array == variant); |
||||
CHECK(array <= variant); |
||||
CHECK(array >= variant); |
||||
CHECK_FALSE(array != variant); |
||||
CHECK_FALSE(array > variant); |
||||
CHECK_FALSE(array < variant); |
||||
|
||||
CHECK(variant == array); |
||||
CHECK(variant <= array); |
||||
CHECK(variant >= array); |
||||
CHECK_FALSE(variant != array); |
||||
CHECK_FALSE(variant > array); |
||||
CHECK_FALSE(variant < array); |
||||
} |
||||
|
||||
SECTION("Compare with different array") { |
||||
JsonArray array = doc.createNestedArray(); |
||||
array.add(1); |
||||
array.add("hello1"); |
||||
array.createNestedObject(); |
||||
|
||||
JsonVariant variant = doc.createNestedArray(); |
||||
variant.add(1); |
||||
variant.add("hello2"); |
||||
variant.createNestedObject(); |
||||
|
||||
CHECK(array != variant); |
||||
CHECK_FALSE(array == variant); |
||||
CHECK_FALSE(array > variant); |
||||
CHECK_FALSE(array < variant); |
||||
CHECK_FALSE(array <= variant); |
||||
CHECK_FALSE(array >= variant); |
||||
} |
||||
} |
||||
|
||||
TEST_CASE("Compare JsonArray with JsonVariantConst") { |
||||
StaticJsonDocument<256> doc; |
||||
|
||||
SECTION("Compare with unbound") { |
||||
JsonArray array = doc.to<JsonArray>(); |
||||
array.add(1); |
||||
array.add("hello"); |
||||
JsonVariantConst unbound; |
||||
|
||||
CHECK(array != unbound); |
||||
CHECK_FALSE(array == unbound); |
||||
CHECK_FALSE(array <= unbound); |
||||
CHECK_FALSE(array >= unbound); |
||||
CHECK_FALSE(array > unbound); |
||||
CHECK_FALSE(array < unbound); |
||||
|
||||
CHECK(unbound != array); |
||||
CHECK_FALSE(unbound == array); |
||||
CHECK_FALSE(unbound <= array); |
||||
CHECK_FALSE(unbound >= array); |
||||
CHECK_FALSE(unbound > array); |
||||
CHECK_FALSE(unbound < array); |
||||
} |
||||
|
||||
SECTION("Compare with self") { |
||||
JsonArray array = doc.to<JsonArray>(); |
||||
array.add(1); |
||||
array.add("hello"); |
||||
|
||||
JsonVariantConst variant = array; |
||||
|
||||
CHECK(array == variant); |
||||
CHECK(array <= variant); |
||||
CHECK(array >= variant); |
||||
CHECK_FALSE(array != variant); |
||||
CHECK_FALSE(array > variant); |
||||
CHECK_FALSE(array < variant); |
||||
|
||||
CHECK(variant == array); |
||||
CHECK(variant <= array); |
||||
CHECK(variant >= array); |
||||
CHECK_FALSE(variant != array); |
||||
CHECK_FALSE(variant > array); |
||||
CHECK_FALSE(variant < array); |
||||
} |
||||
|
||||
SECTION("Compare with identical array") { |
||||
JsonArray array = doc.createNestedArray(); |
||||
array.add(1); |
||||
array.add("hello"); |
||||
array.createNestedObject(); |
||||
|
||||
JsonArray array2 = doc.createNestedArray(); |
||||
array2.add(1); |
||||
array2.add("hello"); |
||||
array2.createNestedObject(); |
||||
JsonVariantConst variant = array2; |
||||
|
||||
CHECK(array == variant); |
||||
CHECK(array <= variant); |
||||
CHECK(array >= variant); |
||||
CHECK_FALSE(array != variant); |
||||
CHECK_FALSE(array > variant); |
||||
CHECK_FALSE(array < variant); |
||||
|
||||
CHECK(variant == array); |
||||
CHECK(variant <= array); |
||||
CHECK(variant >= array); |
||||
CHECK_FALSE(variant != array); |
||||
CHECK_FALSE(variant > array); |
||||
CHECK_FALSE(variant < array); |
||||
} |
||||
|
||||
SECTION("Compare with different array") { |
||||
JsonArray array = doc.createNestedArray(); |
||||
array.add(1); |
||||
array.add("hello1"); |
||||
array.createNestedObject(); |
||||
|
||||
JsonArray array2 = doc.createNestedArray(); |
||||
array2.add(1); |
||||
array2.add("hello2"); |
||||
array2.createNestedObject(); |
||||
JsonVariantConst variant = array2; |
||||
|
||||
CHECK(array != variant); |
||||
CHECK_FALSE(array == variant); |
||||
CHECK_FALSE(array > variant); |
||||
CHECK_FALSE(array < variant); |
||||
CHECK_FALSE(array <= variant); |
||||
CHECK_FALSE(array >= variant); |
||||
} |
||||
} |
||||
|
||||
TEST_CASE("Compare JsonArray with JsonArrayConst") { |
||||
StaticJsonDocument<256> doc; |
||||
|
||||
SECTION("Compare with unbound") { |
||||
JsonArray array = doc.to<JsonArray>(); |
||||
array.add(1); |
||||
array.add("hello"); |
||||
JsonArrayConst unbound; |
||||
|
||||
CHECK(array != unbound); |
||||
CHECK_FALSE(array == unbound); |
||||
CHECK_FALSE(array <= unbound); |
||||
CHECK_FALSE(array >= unbound); |
||||
CHECK_FALSE(array > unbound); |
||||
CHECK_FALSE(array < unbound); |
||||
|
||||
CHECK(unbound != array); |
||||
CHECK_FALSE(unbound == array); |
||||
CHECK_FALSE(unbound <= array); |
||||
CHECK_FALSE(unbound >= array); |
||||
CHECK_FALSE(unbound > array); |
||||
CHECK_FALSE(unbound < array); |
||||
} |
||||
|
||||
SECTION("Compare with self") { |
||||
JsonArray array = doc.to<JsonArray>(); |
||||
array.add(1); |
||||
array.add("hello"); |
||||
JsonArrayConst carray = array; |
||||
|
||||
CHECK(array == carray); |
||||
CHECK(array <= carray); |
||||
CHECK(array >= carray); |
||||
CHECK_FALSE(array != carray); |
||||
CHECK_FALSE(array > carray); |
||||
CHECK_FALSE(array < carray); |
||||
|
||||
CHECK(carray == array); |
||||
CHECK(carray <= array); |
||||
CHECK(carray >= array); |
||||
CHECK_FALSE(carray != array); |
||||
CHECK_FALSE(carray > array); |
||||
CHECK_FALSE(carray < array); |
||||
} |
||||
|
||||
SECTION("Compare with identical array") { |
||||
JsonArray array1 = doc.createNestedArray(); |
||||
array1.add(1); |
||||
array1.add("hello"); |
||||
array1.createNestedObject(); |
||||
|
||||
JsonArray array2 = doc.createNestedArray(); |
||||
array2.add(1); |
||||
array2.add("hello"); |
||||
array2.createNestedObject(); |
||||
JsonArrayConst carray2 = array2; |
||||
|
||||
CHECK(array1 == carray2); |
||||
CHECK(array1 <= carray2); |
||||
CHECK(array1 >= carray2); |
||||
CHECK_FALSE(array1 != carray2); |
||||
CHECK_FALSE(array1 > carray2); |
||||
CHECK_FALSE(array1 < carray2); |
||||
|
||||
CHECK(carray2 == array1); |
||||
CHECK(carray2 <= array1); |
||||
CHECK(carray2 >= array1); |
||||
CHECK_FALSE(carray2 != array1); |
||||
CHECK_FALSE(carray2 > array1); |
||||
CHECK_FALSE(carray2 < array1); |
||||
} |
||||
|
||||
SECTION("Compare with different array") { |
||||
JsonArray array1 = doc.createNestedArray(); |
||||
array1.add(1); |
||||
array1.add("hello1"); |
||||
array1.createNestedObject(); |
||||
|
||||
JsonArray array2 = doc.createNestedArray(); |
||||
array2.add(1); |
||||
array2.add("hello2"); |
||||
array2.createNestedObject(); |
||||
JsonArrayConst carray2 = array2; |
||||
|
||||
CHECK(array1 != carray2); |
||||
CHECK_FALSE(array1 == carray2); |
||||
CHECK_FALSE(array1 > carray2); |
||||
CHECK_FALSE(array1 < carray2); |
||||
CHECK_FALSE(array1 <= carray2); |
||||
CHECK_FALSE(array1 >= carray2); |
||||
|
||||
CHECK(carray2 != array1); |
||||
CHECK_FALSE(carray2 == array1); |
||||
CHECK_FALSE(carray2 > array1); |
||||
CHECK_FALSE(carray2 < array1); |
||||
CHECK_FALSE(carray2 <= array1); |
||||
CHECK_FALSE(carray2 >= array1); |
||||
} |
||||
} |
||||
|
||||
TEST_CASE("Compare JsonArrayConst with JsonArrayConst") { |
||||
StaticJsonDocument<256> doc; |
||||
|
||||
SECTION("Compare with unbound") { |
||||
JsonArray array = doc.to<JsonArray>(); |
||||
array.add(1); |
||||
array.add("hello"); |
||||
|
||||
JsonArrayConst carray = array; |
||||
JsonArrayConst unbound; |
||||
|
||||
CHECK(carray != unbound); |
||||
CHECK_FALSE(carray == unbound); |
||||
CHECK_FALSE(carray <= unbound); |
||||
CHECK_FALSE(carray >= unbound); |
||||
CHECK_FALSE(carray > unbound); |
||||
CHECK_FALSE(carray < unbound); |
||||
|
||||
CHECK(unbound != carray); |
||||
CHECK_FALSE(unbound == carray); |
||||
CHECK_FALSE(unbound <= carray); |
||||
CHECK_FALSE(unbound >= carray); |
||||
CHECK_FALSE(unbound > carray); |
||||
CHECK_FALSE(unbound < carray); |
||||
} |
||||
|
||||
SECTION("Compare with self") { |
||||
JsonArray array = doc.to<JsonArray>(); |
||||
array.add(1); |
||||
array.add("hello"); |
||||
JsonArrayConst carray = array; |
||||
|
||||
CHECK(carray == carray); |
||||
CHECK(carray <= carray); |
||||
CHECK(carray >= carray); |
||||
CHECK_FALSE(carray != carray); |
||||
CHECK_FALSE(carray > carray); |
||||
CHECK_FALSE(carray < carray); |
||||
} |
||||
|
||||
SECTION("Compare with identical array") { |
||||
JsonArray array1 = doc.createNestedArray(); |
||||
array1.add(1); |
||||
array1.add("hello"); |
||||
array1.createNestedObject(); |
||||
JsonArrayConst carray1 = array1; |
||||
|
||||
JsonArray array2 = doc.createNestedArray(); |
||||
array2.add(1); |
||||
array2.add("hello"); |
||||
array2.createNestedObject(); |
||||
JsonArrayConst carray2 = array2; |
||||
|
||||
CHECK(carray1 == carray2); |
||||
CHECK(carray1 <= carray2); |
||||
CHECK(carray1 >= carray2); |
||||
CHECK_FALSE(carray1 != carray2); |
||||
CHECK_FALSE(carray1 > carray2); |
||||
CHECK_FALSE(carray1 < carray2); |
||||
} |
||||
|
||||
SECTION("Compare with different array") { |
||||
JsonArray array1 = doc.createNestedArray(); |
||||
array1.add(1); |
||||
array1.add("hello1"); |
||||
array1.createNestedObject(); |
||||
JsonArrayConst carray1 = array1; |
||||
|
||||
JsonArray array2 = doc.createNestedArray(); |
||||
array2.add(1); |
||||
array2.add("hello2"); |
||||
array2.createNestedObject(); |
||||
JsonArrayConst carray2 = array2; |
||||
|
||||
CHECK(carray1 != carray2); |
||||
CHECK_FALSE(carray1 == carray2); |
||||
CHECK_FALSE(carray1 > carray2); |
||||
CHECK_FALSE(carray1 < carray2); |
||||
CHECK_FALSE(carray1 <= carray2); |
||||
CHECK_FALSE(carray1 >= carray2); |
||||
} |
||||
} |
||||
|
||||
TEST_CASE("Compare JsonArrayConst with JsonVariant") { |
||||
StaticJsonDocument<256> doc; |
||||
|
||||
SECTION("Compare with self") { |
||||
JsonArray array = doc.to<JsonArray>(); |
||||
array.add(1); |
||||
array.add("hello"); |
||||
JsonArrayConst carray = array; |
||||
JsonVariant variant = array; |
||||
|
||||
CHECK(carray == variant); |
||||
CHECK(carray <= variant); |
||||
CHECK(carray >= variant); |
||||
CHECK_FALSE(carray != variant); |
||||
CHECK_FALSE(carray > variant); |
||||
CHECK_FALSE(carray < variant); |
||||
|
||||
CHECK(variant == carray); |
||||
CHECK(variant <= carray); |
||||
CHECK(variant >= carray); |
||||
CHECK_FALSE(variant != carray); |
||||
CHECK_FALSE(variant > carray); |
||||
CHECK_FALSE(variant < carray); |
||||
} |
||||
|
||||
SECTION("Compare with identical array") { |
||||
JsonArray array1 = doc.createNestedArray(); |
||||
array1.add(1); |
||||
array1.add("hello"); |
||||
array1.createNestedObject(); |
||||
JsonArrayConst carray1 = array1; |
||||
|
||||
JsonArray array2 = doc.createNestedArray(); |
||||
array2.add(1); |
||||
array2.add("hello"); |
||||
array2.createNestedObject(); |
||||
JsonVariant variant2 = array2; |
||||
|
||||
CHECK(carray1 == variant2); |
||||
CHECK(carray1 <= variant2); |
||||
CHECK(carray1 >= variant2); |
||||
CHECK_FALSE(carray1 != variant2); |
||||
CHECK_FALSE(carray1 > variant2); |
||||
CHECK_FALSE(carray1 < variant2); |
||||
|
||||
CHECK(variant2 == carray1); |
||||
CHECK(variant2 <= carray1); |
||||
CHECK(variant2 >= carray1); |
||||
CHECK_FALSE(variant2 != carray1); |
||||
CHECK_FALSE(variant2 > carray1); |
||||
CHECK_FALSE(variant2 < carray1); |
||||
} |
||||
|
||||
SECTION("Compare with different array") { |
||||
JsonArray array1 = doc.createNestedArray(); |
||||
array1.add(1); |
||||
array1.add("hello1"); |
||||
array1.createNestedObject(); |
||||
JsonArrayConst carray1 = array1; |
||||
|
||||
JsonArray array2 = doc.createNestedArray(); |
||||
array2.add(1); |
||||
array2.add("hello2"); |
||||
array2.createNestedObject(); |
||||
JsonVariant variant2 = array2; |
||||
|
||||
CHECK(carray1 != variant2); |
||||
CHECK_FALSE(carray1 == variant2); |
||||
CHECK_FALSE(carray1 > variant2); |
||||
CHECK_FALSE(carray1 < variant2); |
||||
CHECK_FALSE(carray1 <= variant2); |
||||
CHECK_FALSE(carray1 >= variant2); |
||||
|
||||
CHECK(variant2 != carray1); |
||||
CHECK_FALSE(variant2 == carray1); |
||||
CHECK_FALSE(variant2 > carray1); |
||||
CHECK_FALSE(variant2 < carray1); |
||||
CHECK_FALSE(variant2 <= carray1); |
||||
CHECK_FALSE(variant2 >= carray1); |
||||
} |
||||
} |
||||
@ -1,16 +0,0 @@ |
||||
// ArduinoJson - https://arduinojson.org
|
||||
// Copyright © 2014-2022, Benoit BLANCHON
|
||||
// MIT License
|
||||
|
||||
#include <ArduinoJson.h> |
||||
#include <catch.hpp> |
||||
|
||||
TEST_CASE("JsonArray::get()") { |
||||
DynamicJsonDocument doc(4096); |
||||
deserializeJson(doc, "[1,2,3]"); |
||||
JsonArray array = doc.as<JsonArray>(); |
||||
|
||||
SECTION("Overflow") { |
||||
REQUIRE(array.getElement(3).isNull()); |
||||
} |
||||
} |
||||
@ -0,0 +1,512 @@ |
||||
// ArduinoJson - https://arduinojson.org
|
||||
// Copyright © 2014-2022, Benoit BLANCHON
|
||||
// MIT License
|
||||
|
||||
#include <ArduinoJson.h> |
||||
#include <catch.hpp> |
||||
|
||||
TEST_CASE("Compare JsonObject with JsonObject") { |
||||
StaticJsonDocument<512> doc; |
||||
|
||||
SECTION("Compare with unbound") { |
||||
JsonObject object = doc.to<JsonObject>(); |
||||
object["a"] = 1; |
||||
object["b"] = "hello"; |
||||
JsonObject unbound; |
||||
|
||||
CHECK(object != unbound); |
||||
CHECK_FALSE(object == unbound); |
||||
CHECK_FALSE(object <= unbound); |
||||
CHECK_FALSE(object >= unbound); |
||||
CHECK_FALSE(object > unbound); |
||||
CHECK_FALSE(object < unbound); |
||||
|
||||
CHECK(unbound != object); |
||||
CHECK_FALSE(unbound == object); |
||||
CHECK_FALSE(unbound <= object); |
||||
CHECK_FALSE(unbound >= object); |
||||
CHECK_FALSE(unbound > object); |
||||
CHECK_FALSE(unbound < object); |
||||
} |
||||
|
||||
SECTION("Compare with self") { |
||||
JsonObject object = doc.to<JsonObject>(); |
||||
object["a"] = 1; |
||||
object["b"] = "hello"; |
||||
|
||||
CHECK(object == object); |
||||
CHECK(object <= object); |
||||
CHECK(object >= object); |
||||
CHECK_FALSE(object != object); |
||||
CHECK_FALSE(object > object); |
||||
CHECK_FALSE(object < object); |
||||
} |
||||
|
||||
SECTION("Compare with identical object") { |
||||
JsonObject object1 = doc.createNestedObject(); |
||||
object1["a"] = 1; |
||||
object1["b"] = "hello"; |
||||
object1["c"][0] = false; |
||||
|
||||
JsonObject object2 = doc.createNestedObject(); |
||||
object2["a"] = 1; |
||||
object2["b"] = "hello"; |
||||
object2["c"][0] = false; |
||||
|
||||
CHECK(object1 == object2); |
||||
CHECK(object1 <= object2); |
||||
CHECK(object1 >= object2); |
||||
CHECK_FALSE(object1 != object2); |
||||
CHECK_FALSE(object1 > object2); |
||||
CHECK_FALSE(object1 < object2); |
||||
} |
||||
|
||||
SECTION("Compare with different object") { |
||||
JsonObject object1 = doc.createNestedObject(); |
||||
object1["a"] = 1; |
||||
object1["b"] = "hello1"; |
||||
object1["c"][0] = false; |
||||
|
||||
JsonObject object2 = doc.createNestedObject(); |
||||
object2["a"] = 1; |
||||
object2["b"] = "hello2"; |
||||
object2["c"][0] = false; |
||||
|
||||
CHECK(object1 != object2); |
||||
CHECK_FALSE(object1 == object2); |
||||
CHECK_FALSE(object1 > object2); |
||||
CHECK_FALSE(object1 < object2); |
||||
CHECK_FALSE(object1 <= object2); |
||||
CHECK_FALSE(object1 >= object2); |
||||
} |
||||
} |
||||
|
||||
TEST_CASE("Compare JsonObject with JsonVariant") { |
||||
StaticJsonDocument<512> doc; |
||||
|
||||
SECTION("Compare with self") { |
||||
JsonObject object = doc.to<JsonObject>(); |
||||
object["a"] = 1; |
||||
object["b"] = "hello"; |
||||
|
||||
JsonVariant variant = object; |
||||
|
||||
CHECK(object == variant); |
||||
CHECK(object <= variant); |
||||
CHECK(object >= variant); |
||||
CHECK_FALSE(object != variant); |
||||
CHECK_FALSE(object > variant); |
||||
CHECK_FALSE(object < variant); |
||||
|
||||
CHECK(variant == object); |
||||
CHECK(variant <= object); |
||||
CHECK(variant >= object); |
||||
CHECK_FALSE(variant != object); |
||||
CHECK_FALSE(variant > object); |
||||
CHECK_FALSE(variant < object); |
||||
} |
||||
|
||||
SECTION("Compare with identical object") { |
||||
JsonObject object = doc.createNestedObject(); |
||||
object["a"] = 1; |
||||
object["b"] = "hello"; |
||||
object["c"][0] = false; |
||||
|
||||
JsonVariant variant = doc.createNestedObject(); |
||||
variant["a"] = 1; |
||||
variant["b"] = "hello"; |
||||
variant["c"][0] = false; |
||||
|
||||
CHECK(object == variant); |
||||
CHECK(object <= variant); |
||||
CHECK(object >= variant); |
||||
CHECK_FALSE(object != variant); |
||||
CHECK_FALSE(object > variant); |
||||
CHECK_FALSE(object < variant); |
||||
|
||||
CHECK(variant == object); |
||||
CHECK(variant <= object); |
||||
CHECK(variant >= object); |
||||
CHECK_FALSE(variant != object); |
||||
CHECK_FALSE(variant > object); |
||||
CHECK_FALSE(variant < object); |
||||
} |
||||
|
||||
SECTION("Compare with different object") { |
||||
JsonObject object = doc.createNestedObject(); |
||||
object["a"] = 1; |
||||
object["b"] = "hello1"; |
||||
object["c"][0] = false; |
||||
|
||||
JsonVariant variant = doc.createNestedObject(); |
||||
variant["a"] = 1; |
||||
variant["b"] = "hello2"; |
||||
variant["c"][0] = false; |
||||
|
||||
CHECK(object != variant); |
||||
CHECK_FALSE(object == variant); |
||||
CHECK_FALSE(object > variant); |
||||
CHECK_FALSE(object < variant); |
||||
CHECK_FALSE(object <= variant); |
||||
CHECK_FALSE(object >= variant); |
||||
} |
||||
} |
||||
|
||||
TEST_CASE("Compare JsonObject with JsonVariantConst") { |
||||
StaticJsonDocument<512> doc; |
||||
|
||||
SECTION("Compare with unbound") { |
||||
JsonObject object = doc.to<JsonObject>(); |
||||
object["a"] = 1; |
||||
object["b"] = "hello"; |
||||
JsonVariantConst unbound; |
||||
|
||||
CHECK(object != unbound); |
||||
CHECK_FALSE(object == unbound); |
||||
CHECK_FALSE(object <= unbound); |
||||
CHECK_FALSE(object >= unbound); |
||||
CHECK_FALSE(object > unbound); |
||||
CHECK_FALSE(object < unbound); |
||||
|
||||
CHECK(unbound != object); |
||||
CHECK_FALSE(unbound == object); |
||||
CHECK_FALSE(unbound <= object); |
||||
CHECK_FALSE(unbound >= object); |
||||
CHECK_FALSE(unbound > object); |
||||
CHECK_FALSE(unbound < object); |
||||
} |
||||
|
||||
SECTION("Compare with self") { |
||||
JsonObject object = doc.to<JsonObject>(); |
||||
object["a"] = 1; |
||||
object["b"] = "hello"; |
||||
|
||||
JsonVariantConst variant = object; |
||||
|
||||
CHECK(object == variant); |
||||
CHECK(object <= variant); |
||||
CHECK(object >= variant); |
||||
CHECK_FALSE(object != variant); |
||||
CHECK_FALSE(object > variant); |
||||
CHECK_FALSE(object < variant); |
||||
|
||||
CHECK(variant == object); |
||||
CHECK(variant <= object); |
||||
CHECK(variant >= object); |
||||
CHECK_FALSE(variant != object); |
||||
CHECK_FALSE(variant > object); |
||||
CHECK_FALSE(variant < object); |
||||
} |
||||
|
||||
SECTION("Compare with identical object") { |
||||
JsonObject object = doc.createNestedObject(); |
||||
object["a"] = 1; |
||||
object["b"] = "hello"; |
||||
object["c"][0] = false; |
||||
|
||||
JsonObject object2 = doc.createNestedObject(); |
||||
object2["a"] = 1; |
||||
object2["b"] = "hello"; |
||||
object2["c"][0] = false; |
||||
JsonVariantConst variant = object2; |
||||
|
||||
CHECK(object == variant); |
||||
CHECK(object <= variant); |
||||
CHECK(object >= variant); |
||||
CHECK_FALSE(object != variant); |
||||
CHECK_FALSE(object > variant); |
||||
CHECK_FALSE(object < variant); |
||||
|
||||
CHECK(variant == object); |
||||
CHECK(variant <= object); |
||||
CHECK(variant >= object); |
||||
CHECK_FALSE(variant != object); |
||||
CHECK_FALSE(variant > object); |
||||
CHECK_FALSE(variant < object); |
||||
} |
||||
|
||||
SECTION("Compare with different object") { |
||||
JsonObject object = doc.createNestedObject(); |
||||
object["a"] = 1; |
||||
object["b"] = "hello1"; |
||||
object["c"][0] = false; |
||||
|
||||
JsonObject object2 = doc.createNestedObject(); |
||||
object2["a"] = 1; |
||||
object2["b"] = "hello2"; |
||||
object2["c"][0] = false; |
||||
JsonVariantConst variant = object2; |
||||
|
||||
CHECK(object != variant); |
||||
CHECK_FALSE(object == variant); |
||||
CHECK_FALSE(object > variant); |
||||
CHECK_FALSE(object < variant); |
||||
CHECK_FALSE(object <= variant); |
||||
CHECK_FALSE(object >= variant); |
||||
} |
||||
} |
||||
|
||||
TEST_CASE("Compare JsonObject with JsonObjectConst") { |
||||
StaticJsonDocument<512> doc; |
||||
|
||||
SECTION("Compare with unbound") { |
||||
JsonObject object = doc.to<JsonObject>(); |
||||
object["a"] = 1; |
||||
object["b"] = "hello"; |
||||
JsonObjectConst unbound; |
||||
|
||||
CHECK(object != unbound); |
||||
CHECK_FALSE(object == unbound); |
||||
CHECK_FALSE(object <= unbound); |
||||
CHECK_FALSE(object >= unbound); |
||||
CHECK_FALSE(object > unbound); |
||||
CHECK_FALSE(object < unbound); |
||||
|
||||
CHECK(unbound != object); |
||||
CHECK_FALSE(unbound == object); |
||||
CHECK_FALSE(unbound <= object); |
||||
CHECK_FALSE(unbound >= object); |
||||
CHECK_FALSE(unbound > object); |
||||
CHECK_FALSE(unbound < object); |
||||
} |
||||
|
||||
SECTION("Compare with self") { |
||||
JsonObject object = doc.to<JsonObject>(); |
||||
object["a"] = 1; |
||||
object["b"] = "hello"; |
||||
JsonObjectConst cobject = object; |
||||
|
||||
CHECK(object == cobject); |
||||
CHECK(object <= cobject); |
||||
CHECK(object >= cobject); |
||||
CHECK_FALSE(object != cobject); |
||||
CHECK_FALSE(object > cobject); |
||||
CHECK_FALSE(object < cobject); |
||||
|
||||
CHECK(cobject == object); |
||||
CHECK(cobject <= object); |
||||
CHECK(cobject >= object); |
||||
CHECK_FALSE(cobject != object); |
||||
CHECK_FALSE(cobject > object); |
||||
CHECK_FALSE(cobject < object); |
||||
} |
||||
|
||||
SECTION("Compare with identical object") { |
||||
JsonObject object1 = doc.createNestedObject(); |
||||
object1["a"] = 1; |
||||
object1["b"] = "hello"; |
||||
object1["c"][0] = false; |
||||
|
||||
JsonObject object2 = doc.createNestedObject(); |
||||
object2["a"] = 1; |
||||
object2["b"] = "hello"; |
||||
object2["c"][0] = false; |
||||
JsonObjectConst carray2 = object2; |
||||
|
||||
CHECK(object1 == carray2); |
||||
CHECK(object1 <= carray2); |
||||
CHECK(object1 >= carray2); |
||||
CHECK_FALSE(object1 != carray2); |
||||
CHECK_FALSE(object1 > carray2); |
||||
CHECK_FALSE(object1 < carray2); |
||||
|
||||
CHECK(carray2 == object1); |
||||
CHECK(carray2 <= object1); |
||||
CHECK(carray2 >= object1); |
||||
CHECK_FALSE(carray2 != object1); |
||||
CHECK_FALSE(carray2 > object1); |
||||
CHECK_FALSE(carray2 < object1); |
||||
} |
||||
|
||||
SECTION("Compare with different object") { |
||||
JsonObject object1 = doc.createNestedObject(); |
||||
object1["a"] = 1; |
||||
object1["b"] = "hello1"; |
||||
object1["c"][0] = false; |
||||
|
||||
JsonObject object2 = doc.createNestedObject(); |
||||
object2["a"] = 1; |
||||
object2["b"] = "hello2"; |
||||
object2["c"][0] = false; |
||||
JsonObjectConst carray2 = object2; |
||||
|
||||
CHECK(object1 != carray2); |
||||
CHECK_FALSE(object1 == carray2); |
||||
CHECK_FALSE(object1 > carray2); |
||||
CHECK_FALSE(object1 < carray2); |
||||
CHECK_FALSE(object1 <= carray2); |
||||
CHECK_FALSE(object1 >= carray2); |
||||
|
||||
CHECK(carray2 != object1); |
||||
CHECK_FALSE(carray2 == object1); |
||||
CHECK_FALSE(carray2 > object1); |
||||
CHECK_FALSE(carray2 < object1); |
||||
CHECK_FALSE(carray2 <= object1); |
||||
CHECK_FALSE(carray2 >= object1); |
||||
} |
||||
} |
||||
|
||||
TEST_CASE("Compare JsonObjectConst with JsonObjectConst") { |
||||
StaticJsonDocument<512> doc; |
||||
|
||||
SECTION("Compare with unbound") { |
||||
JsonObject object = doc.to<JsonObject>(); |
||||
object["a"] = 1; |
||||
object["b"] = "hello"; |
||||
|
||||
JsonObjectConst cobject = object; |
||||
JsonObjectConst unbound; |
||||
|
||||
CHECK(cobject != unbound); |
||||
CHECK_FALSE(cobject == unbound); |
||||
CHECK_FALSE(cobject <= unbound); |
||||
CHECK_FALSE(cobject >= unbound); |
||||
CHECK_FALSE(cobject > unbound); |
||||
CHECK_FALSE(cobject < unbound); |
||||
|
||||
CHECK(unbound != cobject); |
||||
CHECK_FALSE(unbound == cobject); |
||||
CHECK_FALSE(unbound <= cobject); |
||||
CHECK_FALSE(unbound >= cobject); |
||||
CHECK_FALSE(unbound > cobject); |
||||
CHECK_FALSE(unbound < cobject); |
||||
} |
||||
|
||||
SECTION("Compare with self") { |
||||
JsonObject object = doc.to<JsonObject>(); |
||||
object["a"] = 1; |
||||
object["b"] = "hello"; |
||||
JsonObjectConst cobject = object; |
||||
|
||||
CHECK(cobject == cobject); |
||||
CHECK(cobject <= cobject); |
||||
CHECK(cobject >= cobject); |
||||
CHECK_FALSE(cobject != cobject); |
||||
CHECK_FALSE(cobject > cobject); |
||||
CHECK_FALSE(cobject < cobject); |
||||
} |
||||
|
||||
SECTION("Compare with identical object") { |
||||
JsonObject object1 = doc.createNestedObject(); |
||||
object1["a"] = 1; |
||||
object1["b"] = "hello"; |
||||
object1["c"][0] = false; |
||||
JsonObjectConst carray1 = object1; |
||||
|
||||
JsonObject object2 = doc.createNestedObject(); |
||||
object2["a"] = 1; |
||||
object2["b"] = "hello"; |
||||
object2["c"][0] = false; |
||||
JsonObjectConst carray2 = object2; |
||||
|
||||
CHECK(carray1 == carray2); |
||||
CHECK(carray1 <= carray2); |
||||
CHECK(carray1 >= carray2); |
||||
CHECK_FALSE(carray1 != carray2); |
||||
CHECK_FALSE(carray1 > carray2); |
||||
CHECK_FALSE(carray1 < carray2); |
||||
} |
||||
|
||||
SECTION("Compare with different object") { |
||||
JsonObject object1 = doc.createNestedObject(); |
||||
object1["a"] = 1; |
||||
object1["b"] = "hello1"; |
||||
object1["c"][0] = false; |
||||
JsonObjectConst carray1 = object1; |
||||
|
||||
JsonObject object2 = doc.createNestedObject(); |
||||
object2["a"] = 1; |
||||
object2["b"] = "hello2"; |
||||
object2["c"][0] = false; |
||||
JsonObjectConst carray2 = object2; |
||||
|
||||
CHECK(carray1 != carray2); |
||||
CHECK_FALSE(carray1 == carray2); |
||||
CHECK_FALSE(carray1 > carray2); |
||||
CHECK_FALSE(carray1 < carray2); |
||||
CHECK_FALSE(carray1 <= carray2); |
||||
CHECK_FALSE(carray1 >= carray2); |
||||
} |
||||
} |
||||
|
||||
TEST_CASE("Compare JsonObjectConst with JsonVariant") { |
||||
StaticJsonDocument<512> doc; |
||||
|
||||
SECTION("Compare with self") { |
||||
JsonObject object = doc.to<JsonObject>(); |
||||
object["a"] = 1; |
||||
object["b"] = "hello"; |
||||
JsonObjectConst cobject = object; |
||||
JsonVariant variant = object; |
||||
|
||||
CHECK(cobject == variant); |
||||
CHECK(cobject <= variant); |
||||
CHECK(cobject >= variant); |
||||
CHECK_FALSE(cobject != variant); |
||||
CHECK_FALSE(cobject > variant); |
||||
CHECK_FALSE(cobject < variant); |
||||
|
||||
CHECK(variant == cobject); |
||||
CHECK(variant <= cobject); |
||||
CHECK(variant >= cobject); |
||||
CHECK_FALSE(variant != cobject); |
||||
CHECK_FALSE(variant > cobject); |
||||
CHECK_FALSE(variant < cobject); |
||||
} |
||||
|
||||
SECTION("Compare with identical object") { |
||||
JsonObject object1 = doc.createNestedObject(); |
||||
object1["a"] = 1; |
||||
object1["b"] = "hello"; |
||||
object1["c"][0] = false; |
||||
JsonObjectConst carray1 = object1; |
||||
|
||||
JsonObject object2 = doc.createNestedObject(); |
||||
object2["a"] = 1; |
||||
object2["b"] = "hello"; |
||||
object2["c"][0] = false; |
||||
JsonVariant variant2 = object2; |
||||
|
||||
CHECK(carray1 == variant2); |
||||
CHECK(carray1 <= variant2); |
||||
CHECK(carray1 >= variant2); |
||||
CHECK_FALSE(carray1 != variant2); |
||||
CHECK_FALSE(carray1 > variant2); |
||||
CHECK_FALSE(carray1 < variant2); |
||||
|
||||
CHECK(variant2 == carray1); |
||||
CHECK(variant2 <= carray1); |
||||
CHECK(variant2 >= carray1); |
||||
CHECK_FALSE(variant2 != carray1); |
||||
CHECK_FALSE(variant2 > carray1); |
||||
CHECK_FALSE(variant2 < carray1); |
||||
} |
||||
|
||||
SECTION("Compare with different object") { |
||||
JsonObject object1 = doc.createNestedObject(); |
||||
object1["a"] = 1; |
||||
object1["b"] = "hello1"; |
||||
object1["c"][0] = false; |
||||
JsonObjectConst carray1 = object1; |
||||
|
||||
JsonObject object2 = doc.createNestedObject(); |
||||
object2["a"] = 1; |
||||
object2["b"] = "hello2"; |
||||
object2["c"][0] = false; |
||||
JsonVariant variant2 = object2; |
||||
|
||||
CHECK(carray1 != variant2); |
||||
CHECK_FALSE(carray1 == variant2); |
||||
CHECK_FALSE(carray1 > variant2); |
||||
CHECK_FALSE(carray1 < variant2); |
||||
CHECK_FALSE(carray1 <= variant2); |
||||
CHECK_FALSE(carray1 >= variant2); |
||||
|
||||
CHECK(variant2 != carray1); |
||||
CHECK_FALSE(variant2 == carray1); |
||||
CHECK_FALSE(variant2 > carray1); |
||||
CHECK_FALSE(variant2 < carray1); |
||||
CHECK_FALSE(variant2 <= carray1); |
||||
CHECK_FALSE(variant2 >= carray1); |
||||
} |
||||
} |
||||
@ -0,0 +1,87 @@ |
||||
// ArduinoJson - https://arduinojson.org
|
||||
// Copyright © 2014-2022, Benoit BLANCHON
|
||||
// MIT License
|
||||
|
||||
#include <ArduinoJson.h> |
||||
#include <catch.hpp> |
||||
|
||||
TEST_CASE("JsonVariant::shallowCopy()") { |
||||
StaticJsonDocument<1024> doc1, doc2; |
||||
JsonVariant variant = doc1.to<JsonVariant>(); |
||||
|
||||
SECTION("JsonVariant::shallowCopy(JsonDocument&)") { |
||||
doc2["hello"] = "world"; |
||||
|
||||
variant.shallowCopy(doc2); |
||||
|
||||
CHECK(variant.as<std::string>() == "{\"hello\":\"world\"}"); |
||||
|
||||
// altering the linked document should change the result
|
||||
doc2["hello"] = "WORLD!"; |
||||
|
||||
CHECK(variant.as<std::string>() == "{\"hello\":\"WORLD!\"}"); |
||||
} |
||||
|
||||
SECTION("JsonVariant::shallowCopy(MemberProxy)") { |
||||
doc2["obj"]["hello"] = "world"; |
||||
|
||||
variant.shallowCopy(doc2["obj"]); |
||||
|
||||
CHECK(variant.as<std::string>() == "{\"hello\":\"world\"}"); |
||||
|
||||
// altering the linked document should change the result
|
||||
doc2["obj"]["hello"] = "WORLD!"; |
||||
|
||||
CHECK(variant.as<std::string>() == "{\"hello\":\"WORLD!\"}"); |
||||
} |
||||
|
||||
SECTION("JsonVariant::shallowCopy(ElementProxy)") { |
||||
doc2[0]["hello"] = "world"; |
||||
|
||||
variant.shallowCopy(doc2[0]); |
||||
|
||||
CHECK(variant.as<std::string>() == "{\"hello\":\"world\"}"); |
||||
|
||||
// altering the linked document should change the result
|
||||
doc2[0]["hello"] = "WORLD!"; |
||||
|
||||
CHECK(variant.as<std::string>() == "{\"hello\":\"WORLD!\"}"); |
||||
} |
||||
|
||||
SECTION("target is unbound") { |
||||
JsonVariant unbound; |
||||
variant["hello"] = "world"; |
||||
|
||||
variant.shallowCopy(unbound); |
||||
|
||||
CHECK(variant.isUnbound() == false); |
||||
CHECK(variant.isNull() == true); |
||||
CHECK(variant.memoryUsage() == 0); |
||||
CHECK(variant.size() == 0); |
||||
} |
||||
|
||||
SECTION("variant is unbound") { |
||||
JsonVariant unbound; |
||||
doc2["hello"] = "world"; |
||||
|
||||
unbound.shallowCopy(doc2); |
||||
|
||||
CHECK(unbound.isUnbound() == true); |
||||
CHECK(unbound.isNull() == true); |
||||
CHECK(unbound.memoryUsage() == 0); |
||||
CHECK(unbound.size() == 0); |
||||
} |
||||
|
||||
SECTION("preserves owned key bit") { |
||||
doc2.set(42); |
||||
|
||||
doc1["a"].shallowCopy(doc2); |
||||
doc1[std::string("b")].shallowCopy(doc2); |
||||
|
||||
JsonObject::iterator it = doc1.as<JsonObject>().begin(); |
||||
|
||||
CHECK(it->key().isLinked() == true); |
||||
++it; |
||||
CHECK(it->key().isLinked() == false); |
||||
} |
||||
} |
||||
@ -0,0 +1,36 @@ |
||||
// ArduinoJson - https://arduinojson.org
|
||||
// Copyright © 2014-2022, Benoit BLANCHON
|
||||
// MIT License
|
||||
|
||||
#include <ArduinoJson.h> |
||||
#include <catch.hpp> |
||||
|
||||
TEST_CASE("JsonVariant::size()") { |
||||
DynamicJsonDocument doc(4096); |
||||
JsonVariant variant = doc.to<JsonVariant>(); |
||||
|
||||
SECTION("unbound reference") { |
||||
JsonVariant unbound; |
||||
|
||||
CHECK(unbound.size() == 0); |
||||
} |
||||
|
||||
SECTION("int") { |
||||
variant.set(42); |
||||
|
||||
CHECK(variant.size() == 0); |
||||
} |
||||
|
||||
SECTION("string") { |
||||
variant.set("hello"); |
||||
|
||||
CHECK(variant.size() == 0); |
||||
} |
||||
|
||||
SECTION("object") { |
||||
variant["a"] = 1; |
||||
variant["b"] = 2; |
||||
|
||||
CHECK(variant.size() == 2); |
||||
} |
||||
} |
||||
@ -1,115 +0,0 @@ |
||||
// ArduinoJson - https://arduinojson.org
|
||||
// Copyright © 2014-2022, Benoit BLANCHON
|
||||
// MIT License
|
||||
|
||||
#define ARDUINOJSON_DEPRECATED(msg) // nothing
|
||||
|
||||
#include <ArduinoJson.h> |
||||
#include <catch.hpp> |
||||
|
||||
TEST_CASE("Deprecated features") { |
||||
StaticJsonDocument<256> doc; |
||||
const char* s = "hello"; |
||||
doc["s"] = s; |
||||
doc["c"] = 42; |
||||
doc["a"].add(s); |
||||
doc["a"].add(42); |
||||
|
||||
SECTION("JsonVariant::add(char)") { |
||||
JsonVariant v = doc.to<JsonVariant>(); |
||||
v.add('*'); |
||||
REQUIRE(v[0] == 42); |
||||
} |
||||
|
||||
SECTION("JsonVariant::as<char*>()") { |
||||
JsonVariant v = doc["s"]; |
||||
REQUIRE(v.as<char*>() == s); |
||||
} |
||||
|
||||
SECTION("JsonVariant::as<char>()") { |
||||
JsonVariant v = doc["c"]; |
||||
REQUIRE(v.as<char>() == '*'); |
||||
} |
||||
|
||||
SECTION("JsonVariant::is<char*>()") { |
||||
JsonVariant v = doc["s"]; |
||||
REQUIRE(v.is<char*>() == true); |
||||
} |
||||
|
||||
SECTION("JsonVariant::is<char>()") { |
||||
JsonVariant v = doc["c"]; |
||||
REQUIRE(v.is<char>() == true); |
||||
} |
||||
|
||||
SECTION("JsonVariant::set(char)") { |
||||
JsonVariant v = doc.to<JsonVariant>(); |
||||
v.set('*'); |
||||
REQUIRE(v.as<unsigned char>() == 42); |
||||
} |
||||
|
||||
SECTION("JsonVariantConst::as<char*>()") { |
||||
JsonVariantConst v = doc["s"]; |
||||
REQUIRE(v.as<char*>() == s); |
||||
} |
||||
|
||||
SECTION("JsonVariantConst::as<char>()") { |
||||
JsonVariantConst v = doc["c"]; |
||||
REQUIRE(v.as<char>() == '*'); |
||||
} |
||||
|
||||
SECTION("JsonVariantConst::is<char*>()") { |
||||
JsonVariantConst v = doc["s"]; |
||||
REQUIRE(v.is<char*>() == true); |
||||
} |
||||
|
||||
SECTION("JsonVariantConst::is<char>()") { |
||||
JsonVariantConst v = doc["c"]; |
||||
REQUIRE(v.is<char>() == true); |
||||
} |
||||
|
||||
SECTION("MemberProxy::as<char*>()") { |
||||
REQUIRE(doc["s"].as<char*>() == s); |
||||
} |
||||
|
||||
SECTION("MemberProxy::as<char>()") { |
||||
REQUIRE(doc["c"].as<char>() == '*'); |
||||
} |
||||
|
||||
SECTION("MemberProxy::as<char>()") { |
||||
doc["x"].set('*'); |
||||
REQUIRE(doc["x"] == 42); |
||||
} |
||||
|
||||
SECTION("MemberProxy::is<char*>()") { |
||||
REQUIRE(doc["s"].is<char*>() == true); |
||||
REQUIRE(doc["c"].is<char*>() == false); |
||||
} |
||||
|
||||
SECTION("MemberProxy::is<char>()") { |
||||
REQUIRE(doc["c"].is<char>() == true); |
||||
REQUIRE(doc["s"].is<char>() == false); |
||||
} |
||||
|
||||
SECTION("ElementProxy::as<char*>()") { |
||||
REQUIRE(doc["a"][0].as<char*>() == s); |
||||
} |
||||
|
||||
SECTION("ElementProxy::as<char>()") { |
||||
REQUIRE(doc["a"][1].as<char>() == '*'); |
||||
} |
||||
|
||||
SECTION("ElementProxy::as<char>()") { |
||||
doc["a"][0].set('*'); |
||||
REQUIRE(doc["a"][0] == 42); |
||||
} |
||||
|
||||
SECTION("ElementProxy::is<char*>()") { |
||||
REQUIRE(doc["a"][0].is<char*>() == true); |
||||
REQUIRE(doc["a"][1].is<char*>() == false); |
||||
} |
||||
|
||||
SECTION("ElementProxy::is<char>()") { |
||||
REQUIRE(doc["a"][1].is<char>() == true); |
||||
REQUIRE(doc["a"][0].is<char>() == false); |
||||
} |
||||
} |
||||
|
After Width: | Height: | Size: 17 KiB |
@ -1,31 +0,0 @@ |
||||
// ArduinoJson - https://arduinojson.org
|
||||
// Copyright © 2014-2022, Benoit BLANCHON
|
||||
// MIT License
|
||||
|
||||
#pragma once |
||||
|
||||
#include <ArduinoJson/Collection/CollectionData.hpp> |
||||
|
||||
namespace ARDUINOJSON_NAMESPACE { |
||||
|
||||
inline VariantData *arrayAdd(CollectionData *arr, MemoryPool *pool) { |
||||
return arr ? arr->addElement(pool) : 0; |
||||
} |
||||
|
||||
template <typename TVisitor> |
||||
inline typename TVisitor::result_type arrayAccept(const CollectionData *arr, |
||||
TVisitor &visitor) { |
||||
if (arr) |
||||
return visitor.visitArray(*arr); |
||||
else |
||||
return visitor.visitNull(); |
||||
} |
||||
|
||||
inline bool arrayEquals(const CollectionData *lhs, const CollectionData *rhs) { |
||||
if (lhs == rhs) |
||||
return true; |
||||
if (!lhs || !rhs) |
||||
return false; |
||||
return lhs->equalsArray(*rhs); |
||||
} |
||||
} // namespace ARDUINOJSON_NAMESPACE
|
||||
@ -1,28 +0,0 @@ |
||||
// ArduinoJson - https://arduinojson.org
|
||||
// Copyright © 2014-2022, Benoit BLANCHON
|
||||
// MIT License
|
||||
|
||||
#pragma once |
||||
|
||||
#include <ArduinoJson/Array/ArrayRef.hpp> |
||||
#include <ArduinoJson/Object/ObjectRef.hpp> |
||||
|
||||
namespace ARDUINOJSON_NAMESPACE { |
||||
|
||||
template <typename TArray> |
||||
inline ArrayRef ArrayShortcuts<TArray>::createNestedArray() const { |
||||
return impl()->addElement().template to<ArrayRef>(); |
||||
} |
||||
|
||||
template <typename TArray> |
||||
inline ObjectRef ArrayShortcuts<TArray>::createNestedObject() const { |
||||
return impl()->addElement().template to<ObjectRef>(); |
||||
} |
||||
|
||||
template <typename TArray> |
||||
inline ElementProxy<TArray> ArrayShortcuts<TArray>::operator[]( |
||||
size_t index) const { |
||||
return ElementProxy<TArray>(*impl(), index); |
||||
} |
||||
|
||||
} // namespace ARDUINOJSON_NAMESPACE
|
||||
@ -1,121 +0,0 @@ |
||||
// ArduinoJson - https://arduinojson.org
|
||||
// Copyright © 2014-2022, Benoit BLANCHON
|
||||
// MIT License
|
||||
|
||||
#pragma once |
||||
|
||||
#include <ArduinoJson/Variant/SlotFunctions.hpp> |
||||
#include <ArduinoJson/Variant/VariantRef.hpp> |
||||
|
||||
namespace ARDUINOJSON_NAMESPACE { |
||||
|
||||
class VariantPtr { |
||||
public: |
||||
VariantPtr(MemoryPool *pool, VariantData *data) : _variant(pool, data) {} |
||||
|
||||
VariantRef *operator->() { |
||||
return &_variant; |
||||
} |
||||
|
||||
VariantRef &operator*() { |
||||
return _variant; |
||||
} |
||||
|
||||
private: |
||||
VariantRef _variant; |
||||
}; |
||||
|
||||
class ArrayIterator { |
||||
public: |
||||
ArrayIterator() : _slot(0) {} |
||||
explicit ArrayIterator(MemoryPool *pool, VariantSlot *slot) |
||||
: _pool(pool), _slot(slot) {} |
||||
|
||||
VariantRef operator*() const { |
||||
return VariantRef(_pool, _slot->data()); |
||||
} |
||||
VariantPtr operator->() { |
||||
return VariantPtr(_pool, _slot->data()); |
||||
} |
||||
|
||||
bool operator==(const ArrayIterator &other) const { |
||||
return _slot == other._slot; |
||||
} |
||||
|
||||
bool operator!=(const ArrayIterator &other) const { |
||||
return _slot != other._slot; |
||||
} |
||||
|
||||
ArrayIterator &operator++() { |
||||
_slot = _slot->next(); |
||||
return *this; |
||||
} |
||||
|
||||
ArrayIterator &operator+=(size_t distance) { |
||||
_slot = _slot->next(distance); |
||||
return *this; |
||||
} |
||||
|
||||
VariantSlot *internal() { |
||||
return _slot; |
||||
} |
||||
|
||||
private: |
||||
MemoryPool *_pool; |
||||
VariantSlot *_slot; |
||||
}; |
||||
|
||||
class VariantConstPtr { |
||||
public: |
||||
VariantConstPtr(const VariantData *data) : _variant(data) {} |
||||
|
||||
VariantConstRef *operator->() { |
||||
return &_variant; |
||||
} |
||||
|
||||
VariantConstRef &operator*() { |
||||
return _variant; |
||||
} |
||||
|
||||
private: |
||||
VariantConstRef _variant; |
||||
}; |
||||
|
||||
class ArrayConstRefIterator { |
||||
public: |
||||
ArrayConstRefIterator() : _slot(0) {} |
||||
explicit ArrayConstRefIterator(const VariantSlot *slot) : _slot(slot) {} |
||||
|
||||
VariantConstRef operator*() const { |
||||
return VariantConstRef(_slot->data()); |
||||
} |
||||
VariantConstPtr operator->() { |
||||
return VariantConstPtr(_slot->data()); |
||||
} |
||||
|
||||
bool operator==(const ArrayConstRefIterator &other) const { |
||||
return _slot == other._slot; |
||||
} |
||||
|
||||
bool operator!=(const ArrayConstRefIterator &other) const { |
||||
return _slot != other._slot; |
||||
} |
||||
|
||||
ArrayConstRefIterator &operator++() { |
||||
_slot = _slot->next(); |
||||
return *this; |
||||
} |
||||
|
||||
ArrayConstRefIterator &operator+=(size_t distance) { |
||||
_slot = _slot->next(distance); |
||||
return *this; |
||||
} |
||||
|
||||
const VariantSlot *internal() { |
||||
return _slot; |
||||
} |
||||
|
||||
private: |
||||
const VariantSlot *_slot; |
||||
}; |
||||
} // namespace ARDUINOJSON_NAMESPACE
|
||||
@ -1,213 +0,0 @@ |
||||
// ArduinoJson - https://arduinojson.org
|
||||
// Copyright © 2014-2022, Benoit BLANCHON
|
||||
// MIT License
|
||||
|
||||
#pragma once |
||||
|
||||
#include <ArduinoJson/Array/ArrayFunctions.hpp> |
||||
#include <ArduinoJson/Array/ArrayIterator.hpp> |
||||
#include <ArduinoJson/Variant/VariantData.hpp> |
||||
|
||||
// Returns the size (in bytes) of an array with n elements.
|
||||
// Can be very handy to determine the size of a StaticMemoryPool.
|
||||
#define JSON_ARRAY_SIZE(NUMBER_OF_ELEMENTS) \ |
||||
((NUMBER_OF_ELEMENTS) * sizeof(ARDUINOJSON_NAMESPACE::VariantSlot)) |
||||
|
||||
namespace ARDUINOJSON_NAMESPACE { |
||||
|
||||
class ObjectRef; |
||||
template <typename> |
||||
class ElementProxy; |
||||
|
||||
template <typename TData> |
||||
class ArrayRefBase { |
||||
public: |
||||
operator VariantConstRef() const { |
||||
const void* data = _data; // prevent warning cast-align
|
||||
return VariantConstRef(reinterpret_cast<const VariantData*>(data)); |
||||
} |
||||
|
||||
template <typename TVisitor> |
||||
FORCE_INLINE typename TVisitor::result_type accept(TVisitor& visitor) const { |
||||
return arrayAccept(_data, visitor); |
||||
} |
||||
|
||||
FORCE_INLINE bool isNull() const { |
||||
return _data == 0; |
||||
} |
||||
|
||||
FORCE_INLINE operator bool() const { |
||||
return _data != 0; |
||||
} |
||||
|
||||
FORCE_INLINE size_t memoryUsage() const { |
||||
return _data ? _data->memoryUsage() : 0; |
||||
} |
||||
|
||||
FORCE_INLINE size_t nesting() const { |
||||
return _data ? _data->nesting() : 0; |
||||
} |
||||
|
||||
FORCE_INLINE size_t size() const { |
||||
return _data ? _data->size() : 0; |
||||
} |
||||
|
||||
protected: |
||||
ArrayRefBase(TData* data) : _data(data) {} |
||||
TData* _data; |
||||
}; |
||||
|
||||
class ArrayConstRef : public ArrayRefBase<const CollectionData>, |
||||
public Visitable { |
||||
friend class ArrayRef; |
||||
typedef ArrayRefBase<const CollectionData> base_type; |
||||
|
||||
public: |
||||
typedef ArrayConstRefIterator iterator; |
||||
|
||||
FORCE_INLINE iterator begin() const { |
||||
if (!_data) |
||||
return iterator(); |
||||
return iterator(_data->head()); |
||||
} |
||||
|
||||
FORCE_INLINE iterator end() const { |
||||
return iterator(); |
||||
} |
||||
|
||||
FORCE_INLINE ArrayConstRef() : base_type(0) {} |
||||
FORCE_INLINE ArrayConstRef(const CollectionData* data) : base_type(data) {} |
||||
|
||||
FORCE_INLINE bool operator==(ArrayConstRef rhs) const { |
||||
return arrayEquals(_data, rhs._data); |
||||
} |
||||
|
||||
FORCE_INLINE VariantConstRef operator[](size_t index) const { |
||||
return getElement(index); |
||||
} |
||||
|
||||
FORCE_INLINE VariantConstRef getElement(size_t index) const { |
||||
return VariantConstRef(_data ? _data->getElement(index) : 0); |
||||
} |
||||
}; |
||||
|
||||
class ArrayRef : public ArrayRefBase<CollectionData>, |
||||
public ArrayShortcuts<ArrayRef>, |
||||
public Visitable { |
||||
typedef ArrayRefBase<CollectionData> base_type; |
||||
|
||||
public: |
||||
typedef ArrayIterator iterator; |
||||
|
||||
FORCE_INLINE ArrayRef() : base_type(0), _pool(0) {} |
||||
FORCE_INLINE ArrayRef(MemoryPool* pool, CollectionData* data) |
||||
: base_type(data), _pool(pool) {} |
||||
|
||||
operator VariantRef() { |
||||
void* data = _data; // prevent warning cast-align
|
||||
return VariantRef(_pool, reinterpret_cast<VariantData*>(data)); |
||||
} |
||||
|
||||
operator ArrayConstRef() const { |
||||
return ArrayConstRef(_data); |
||||
} |
||||
|
||||
VariantRef addElement() const { |
||||
return VariantRef(_pool, arrayAdd(_data, _pool)); |
||||
} |
||||
|
||||
FORCE_INLINE iterator begin() const { |
||||
if (!_data) |
||||
return iterator(); |
||||
return iterator(_pool, _data->head()); |
||||
} |
||||
|
||||
FORCE_INLINE iterator end() const { |
||||
return iterator(); |
||||
} |
||||
|
||||
// Copy a ArrayRef
|
||||
FORCE_INLINE bool set(ArrayConstRef src) const { |
||||
if (!_data || !src._data) |
||||
return false; |
||||
return _data->copyFrom(*src._data, _pool); |
||||
} |
||||
|
||||
FORCE_INLINE bool operator==(ArrayRef rhs) const { |
||||
return arrayEquals(_data, rhs._data); |
||||
} |
||||
|
||||
// Internal use
|
||||
FORCE_INLINE VariantRef getOrAddElement(size_t index) const { |
||||
return VariantRef(_pool, _data ? _data->getOrAddElement(index, _pool) : 0); |
||||
} |
||||
|
||||
// Gets the value at the specified index.
|
||||
FORCE_INLINE VariantRef getElement(size_t index) const { |
||||
return VariantRef(_pool, _data ? _data->getElement(index) : 0); |
||||
} |
||||
|
||||
// Removes element at specified position.
|
||||
FORCE_INLINE void remove(iterator it) const { |
||||
if (!_data) |
||||
return; |
||||
_data->removeSlot(it.internal()); |
||||
} |
||||
|
||||
// Removes element at specified index.
|
||||
FORCE_INLINE void remove(size_t index) const { |
||||
if (!_data) |
||||
return; |
||||
_data->removeElement(index); |
||||
} |
||||
|
||||
void clear() const { |
||||
if (!_data) |
||||
return; |
||||
_data->clear(); |
||||
} |
||||
|
||||
private: |
||||
MemoryPool* _pool; |
||||
}; |
||||
|
||||
template <> |
||||
struct Converter<ArrayConstRef> { |
||||
static void toJson(VariantConstRef src, VariantRef dst) { |
||||
variantCopyFrom(getData(dst), getData(src), getPool(dst)); |
||||
} |
||||
|
||||
static ArrayConstRef fromJson(VariantConstRef src) { |
||||
return ArrayConstRef(variantAsArray(getData(src))); |
||||
} |
||||
|
||||
static bool checkJson(VariantConstRef src) { |
||||
const VariantData* data = getData(src); |
||||
return data && data->isArray(); |
||||
} |
||||
}; |
||||
|
||||
template <> |
||||
struct Converter<ArrayRef> { |
||||
static void toJson(VariantConstRef src, VariantRef dst) { |
||||
variantCopyFrom(getData(dst), getData(src), getPool(dst)); |
||||
} |
||||
|
||||
static ArrayRef fromJson(VariantRef src) { |
||||
VariantData* data = getData(src); |
||||
MemoryPool* pool = getPool(src); |
||||
return ArrayRef(pool, data != 0 ? data->asArray() : 0); |
||||
} |
||||
|
||||
static InvalidConversion<VariantConstRef, ArrayRef> fromJson(VariantConstRef); |
||||
|
||||
static bool checkJson(VariantConstRef) { |
||||
return false; |
||||
} |
||||
|
||||
static bool checkJson(VariantRef src) { |
||||
VariantData* data = getData(src); |
||||
return data && data->isArray(); |
||||
} |
||||
}; |
||||
} // namespace ARDUINOJSON_NAMESPACE
|
||||
@ -1,49 +0,0 @@ |
||||
// ArduinoJson - https://arduinojson.org
|
||||
// Copyright © 2014-2022, Benoit BLANCHON
|
||||
// MIT License
|
||||
|
||||
#pragma once |
||||
|
||||
#include <ArduinoJson/Polyfills/attributes.hpp> |
||||
#include <ArduinoJson/Polyfills/type_traits.hpp> |
||||
|
||||
namespace ARDUINOJSON_NAMESPACE { |
||||
// Forward declarations.
|
||||
class ArrayRef; |
||||
class ObjectRef; |
||||
template <typename> |
||||
class ElementProxy; |
||||
|
||||
template <typename TArray> |
||||
class ArrayShortcuts { |
||||
public: |
||||
// Returns the element at specified index if the variant is an array.
|
||||
FORCE_INLINE ElementProxy<TArray> operator[](size_t index) const; |
||||
|
||||
FORCE_INLINE ObjectRef createNestedObject() const; |
||||
|
||||
FORCE_INLINE ArrayRef createNestedArray() const; |
||||
|
||||
// Adds the specified value at the end of the array.
|
||||
//
|
||||
// bool add(TValue);
|
||||
// TValue = bool, long, int, short, float, double, serialized, VariantRef,
|
||||
// std::string, String, ObjectRef
|
||||
template <typename T> |
||||
FORCE_INLINE bool add(const T &value) const { |
||||
return impl()->addElement().set(value); |
||||
} |
||||
//
|
||||
// bool add(TValue);
|
||||
// TValue = char*, const char*, const __FlashStringHelper*
|
||||
template <typename T> |
||||
FORCE_INLINE bool add(T *value) const { |
||||
return impl()->addElement().set(value); |
||||
} |
||||
|
||||
private: |
||||
const TArray *impl() const { |
||||
return static_cast<const TArray *>(this); |
||||
} |
||||
}; |
||||
} // namespace ARDUINOJSON_NAMESPACE
|
||||
@ -0,0 +1,134 @@ |
||||
// ArduinoJson - https://arduinojson.org
|
||||
// Copyright © 2014-2022, Benoit BLANCHON
|
||||
// MIT License
|
||||
|
||||
#pragma once |
||||
|
||||
#include <ArduinoJson/Array/JsonArrayIterator.hpp> |
||||
#include <ArduinoJson/Variant/VariantAttorney.hpp> |
||||
#include <ArduinoJson/Variant/VariantData.hpp> |
||||
|
||||
namespace ARDUINOJSON_NAMESPACE { |
||||
|
||||
class JsonObject; |
||||
|
||||
// A read-only reference to an array in a JsonDocument
|
||||
// https://arduinojson.org/v6/api/jsonarrayconst/
|
||||
class JsonArrayConst : public VariantOperators<JsonArrayConst> { |
||||
friend class JsonArray; |
||||
friend class VariantAttorney; |
||||
|
||||
public: |
||||
typedef JsonArrayConstIterator iterator; |
||||
|
||||
// Returns an iterator to the first element of the array.
|
||||
// https://arduinojson.org/v6/api/jsonarrayconst/begin/
|
||||
FORCE_INLINE iterator begin() const { |
||||
if (!_data) |
||||
return iterator(); |
||||
return iterator(_data->head()); |
||||
} |
||||
|
||||
// Returns an iterator to the element following the last element of the array.
|
||||
// https://arduinojson.org/v6/api/jsonarrayconst/end/
|
||||
FORCE_INLINE iterator end() const { |
||||
return iterator(); |
||||
} |
||||
|
||||
// Creates an unbound reference.
|
||||
FORCE_INLINE JsonArrayConst() : _data(0) {} |
||||
|
||||
// INTERNAL USE ONLY
|
||||
FORCE_INLINE JsonArrayConst(const CollectionData* data) : _data(data) {} |
||||
|
||||
// Compares the content of two arrays.
|
||||
// Returns true if the two arrays are equal.
|
||||
FORCE_INLINE bool operator==(JsonArrayConst rhs) const { |
||||
if (_data == rhs._data) |
||||
return true; |
||||
if (!_data || !rhs._data) |
||||
return false; |
||||
|
||||
iterator it1 = begin(); |
||||
iterator it2 = rhs.begin(); |
||||
|
||||
for (;;) { |
||||
bool end1 = it1 == end(); |
||||
bool end2 = it2 == rhs.end(); |
||||
if (end1 && end2) |
||||
return true; |
||||
if (end1 || end2) |
||||
return false; |
||||
if (*it1 != *it2) |
||||
return false; |
||||
++it1; |
||||
++it2; |
||||
} |
||||
} |
||||
|
||||
// Returns the element at the specified index.
|
||||
// https://arduinojson.org/v6/api/jsonarrayconst/subscript/
|
||||
FORCE_INLINE JsonVariantConst operator[](size_t index) const { |
||||
return JsonVariantConst(_data ? _data->getElement(index) : 0); |
||||
} |
||||
|
||||
operator JsonVariantConst() const { |
||||
return JsonVariantConst(collectionToVariant(_data)); |
||||
} |
||||
|
||||
// Returns true if the reference is unbound.
|
||||
// https://arduinojson.org/v6/api/jsonarrayconst/isnull/
|
||||
FORCE_INLINE bool isNull() const { |
||||
return _data == 0; |
||||
} |
||||
|
||||
// Returns true if the reference is bound.
|
||||
// https://arduinojson.org/v6/api/jsonarrayconst/isnull/
|
||||
FORCE_INLINE operator bool() const { |
||||
return _data != 0; |
||||
} |
||||
|
||||
// Returns the number of bytes occupied by the array.
|
||||
// https://arduinojson.org/v6/api/jsonarrayconst/memoryusage/
|
||||
FORCE_INLINE size_t memoryUsage() const { |
||||
return _data ? _data->memoryUsage() : 0; |
||||
} |
||||
|
||||
// Returns the depth (nesting level) of the array.
|
||||
// https://arduinojson.org/v6/api/jsonarrayconst/nesting/
|
||||
FORCE_INLINE size_t nesting() const { |
||||
return variantNesting(collectionToVariant(_data)); |
||||
} |
||||
|
||||
// Returns the number of elements in the array.
|
||||
// https://arduinojson.org/v6/api/jsonarrayconst/size/
|
||||
FORCE_INLINE size_t size() const { |
||||
return _data ? _data->size() : 0; |
||||
} |
||||
|
||||
private: |
||||
const VariantData* getData() const { |
||||
return collectionToVariant(_data); |
||||
} |
||||
|
||||
const CollectionData* _data; |
||||
}; |
||||
|
||||
template <> |
||||
struct Converter<JsonArrayConst> : private VariantAttorney { |
||||
static void toJson(JsonVariantConst src, JsonVariant dst) { |
||||
variantCopyFrom(getData(dst), getData(src), getPool(dst)); |
||||
} |
||||
|
||||
static JsonArrayConst fromJson(JsonVariantConst src) { |
||||
const VariantData* data = getData(src); |
||||
return data ? data->asArray() : 0; |
||||
} |
||||
|
||||
static bool checkJson(JsonVariantConst src) { |
||||
const VariantData* data = getData(src); |
||||
return data && data->isArray(); |
||||
} |
||||
}; |
||||
|
||||
} // namespace ARDUINOJSON_NAMESPACE
|
||||
@ -0,0 +1,32 @@ |
||||
// ArduinoJson - https://arduinojson.org
|
||||
// Copyright © 2014-2022, Benoit BLANCHON
|
||||
// MIT License
|
||||
|
||||
#pragma once |
||||
|
||||
#include <ArduinoJson/Array/JsonArray.hpp> |
||||
#include <ArduinoJson/Object/JsonObject.hpp> |
||||
|
||||
namespace ARDUINOJSON_NAMESPACE { |
||||
|
||||
inline JsonObject JsonArray::createNestedObject() const { |
||||
return add().to<JsonObject>(); |
||||
} |
||||
|
||||
template <typename TDerived> |
||||
inline JsonArray VariantRefBase<TDerived>::createNestedArray() const { |
||||
return add().template to<JsonArray>(); |
||||
} |
||||
|
||||
template <typename TDerived> |
||||
inline JsonObject VariantRefBase<TDerived>::createNestedObject() const { |
||||
return add().template to<JsonObject>(); |
||||
} |
||||
|
||||
template <typename TDerived> |
||||
inline ElementProxy<TDerived> VariantRefBase<TDerived>::operator[]( |
||||
size_t index) const { |
||||
return ElementProxy<TDerived>(derived(), index); |
||||
} |
||||
|
||||
} // namespace ARDUINOJSON_NAMESPACE
|
||||
@ -0,0 +1,117 @@ |
||||
// ArduinoJson - https://arduinojson.org
|
||||
// Copyright © 2014-2022, Benoit BLANCHON
|
||||
// MIT License
|
||||
|
||||
#pragma once |
||||
|
||||
#include <ArduinoJson/Variant/JsonVariant.hpp> |
||||
#include <ArduinoJson/Variant/SlotFunctions.hpp> |
||||
|
||||
namespace ARDUINOJSON_NAMESPACE { |
||||
|
||||
class VariantPtr { |
||||
public: |
||||
VariantPtr(MemoryPool* pool, VariantData* data) : _variant(pool, data) {} |
||||
|
||||
JsonVariant* operator->() { |
||||
return &_variant; |
||||
} |
||||
|
||||
JsonVariant& operator*() { |
||||
return _variant; |
||||
} |
||||
|
||||
private: |
||||
JsonVariant _variant; |
||||
}; |
||||
|
||||
class JsonArrayIterator { |
||||
friend class JsonArray; |
||||
|
||||
public: |
||||
JsonArrayIterator() : _slot(0) {} |
||||
explicit JsonArrayIterator(MemoryPool* pool, VariantSlot* slot) |
||||
: _pool(pool), _slot(slot) {} |
||||
|
||||
JsonVariant operator*() const { |
||||
return JsonVariant(_pool, _slot->data()); |
||||
} |
||||
VariantPtr operator->() { |
||||
return VariantPtr(_pool, _slot->data()); |
||||
} |
||||
|
||||
bool operator==(const JsonArrayIterator& other) const { |
||||
return _slot == other._slot; |
||||
} |
||||
|
||||
bool operator!=(const JsonArrayIterator& other) const { |
||||
return _slot != other._slot; |
||||
} |
||||
|
||||
JsonArrayIterator& operator++() { |
||||
_slot = _slot->next(); |
||||
return *this; |
||||
} |
||||
|
||||
JsonArrayIterator& operator+=(size_t distance) { |
||||
_slot = _slot->next(distance); |
||||
return *this; |
||||
} |
||||
|
||||
private: |
||||
MemoryPool* _pool; |
||||
VariantSlot* _slot; |
||||
}; |
||||
|
||||
class VariantConstPtr { |
||||
public: |
||||
VariantConstPtr(const VariantData* data) : _variant(data) {} |
||||
|
||||
JsonVariantConst* operator->() { |
||||
return &_variant; |
||||
} |
||||
|
||||
JsonVariantConst& operator*() { |
||||
return _variant; |
||||
} |
||||
|
||||
private: |
||||
JsonVariantConst _variant; |
||||
}; |
||||
|
||||
class JsonArrayConstIterator { |
||||
friend class JsonArray; |
||||
|
||||
public: |
||||
JsonArrayConstIterator() : _slot(0) {} |
||||
explicit JsonArrayConstIterator(const VariantSlot* slot) : _slot(slot) {} |
||||
|
||||
JsonVariantConst operator*() const { |
||||
return JsonVariantConst(_slot->data()); |
||||
} |
||||
VariantConstPtr operator->() { |
||||
return VariantConstPtr(_slot->data()); |
||||
} |
||||
|
||||
bool operator==(const JsonArrayConstIterator& other) const { |
||||
return _slot == other._slot; |
||||
} |
||||
|
||||
bool operator!=(const JsonArrayConstIterator& other) const { |
||||
return _slot != other._slot; |
||||
} |
||||
|
||||
JsonArrayConstIterator& operator++() { |
||||
_slot = _slot->next(); |
||||
return *this; |
||||
} |
||||
|
||||
JsonArrayConstIterator& operator+=(size_t distance) { |
||||
_slot = _slot->next(distance); |
||||
return *this; |
||||
} |
||||
|
||||
private: |
||||
const VariantSlot* _slot; |
||||
}; |
||||
} // namespace ARDUINOJSON_NAMESPACE
|
||||
@ -1,21 +0,0 @@ |
||||
// ArduinoJson - https://arduinojson.org
|
||||
// Copyright © 2014-2022, Benoit BLANCHON
|
||||
// MIT License
|
||||
|
||||
#pragma once |
||||
|
||||
#include <ArduinoJson/Polyfills/type_traits.hpp> |
||||
|
||||
namespace ARDUINOJSON_NAMESPACE { |
||||
|
||||
struct Visitable { |
||||
// template<Visitor>
|
||||
// void accept(Visitor&) const;
|
||||
}; |
||||
|
||||
template <typename T> |
||||
struct IsVisitable : is_base_of<Visitable, T> {}; |
||||
|
||||
template <typename T> |
||||
struct IsVisitable<T &> : IsVisitable<T> {}; |
||||
} // namespace ARDUINOJSON_NAMESPACE
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue