Allow using a JsonVariant as a key or index

Closes #2080

extras/tests/JsonArray/remove.cpp

@@ -88,6 +88,15 @@ TEST_CASE("JsonArray::remove()") {
     JsonArray unboundArray;
     unboundArray.remove(unboundArray.begin());
   }
+
+  SECTION("use JsonVariant as index") {
+    array.remove(array[3]);  // no effect with null variant
+    array.remove(array[0]);  // remove element at index 1
+
+    REQUIRE(2 == array.size());
+    REQUIRE(array[0] == 1);
+    REQUIRE(array[1] == 3);
+  }
 }
 
 TEST_CASE("Removed elements are recycled") {

extras/tests/JsonArray/subscript.cpp

@@ -164,4 +164,13 @@ TEST_CASE("JsonArray::operator[]") {
     REQUIRE(std::string("world") == array[0]);
   }
 #endif
+
+  SECTION("Use a JsonVariant as index") {
+    array[0] = 1;
+    array[1] = 2;
+    array[2] = 3;
+
+    REQUIRE(array[array[1]] == 3);
+    REQUIRE(array[array[3]] == nullptr);
+  }
 }

extras/tests/JsonArrayConst/subscript.cpp

@@ -13,8 +13,15 @@ TEST_CASE("JsonArrayConst::operator[]") {
   doc.add(2);
   doc.add(3);
 
-  REQUIRE(1 == arr[0].as<int>());
-  REQUIRE(2 == arr[1].as<int>());
-  REQUIRE(3 == arr[2].as<int>());
-  REQUIRE(0 == arr[3].as<int>());
+  SECTION("int") {
+    REQUIRE(1 == arr[0].as<int>());
+    REQUIRE(2 == arr[1].as<int>());
+    REQUIRE(3 == arr[2].as<int>());
+    REQUIRE(0 == arr[3].as<int>());
+  }
+
+  SECTION("JsonVariant") {
+    REQUIRE(2 == arr[arr[0]].as<int>());
+    REQUIRE(0 == arr[arr[3]].as<int>());
+  }
 }

extras/tests/JsonDocument/containsKey.cpp

@@ -41,4 +41,12 @@ TEST_CASE("JsonDocument::containsKey()") {
   SECTION("returns false on null") {
     REQUIRE(doc.containsKey("hello") == false);
   }
+
+  SECTION("support JsonVariant") {
+    doc["hello"] = "world";
+    doc["key"] = "hello";
+
+    REQUIRE(doc.containsKey(doc["key"]) == true);
+    REQUIRE(doc.containsKey(doc["foo"]) == false);
+  }
 }

extras/tests/JsonDocument/remove.cpp

@@ -49,4 +49,25 @@ TEST_CASE("JsonDocument::remove()") {
     REQUIRE(doc.as<std::string>() == "{\"a\":1}");
   }
 #endif
+
+  SECTION("remove(JsonVariant) from object") {
+    doc["a"] = 1;
+    doc["b"] = 2;
+    doc["c"] = "b";
+
+    doc.remove(doc["c"]);
+
+    REQUIRE(doc.as<std::string>() == "{\"a\":1,\"c\":\"b\"}");
+  }
+
+  SECTION("remove(JsonVariant) from array") {
+    doc[0] = 3;
+    doc[1] = 2;
+    doc[2] = 1;
+
+    doc.remove(doc[2]);
+    doc.remove(doc[3]);  // noop
+
+    REQUIRE(doc.as<std::string>() == "[3,1]");
+  }
 }

extras/tests/JsonDocument/subscript.cpp

@@ -22,6 +22,12 @@ TEST_CASE("JsonDocument::operator[]") {
       REQUIRE(cdoc[std::string("hello")] == "world");
     }
 
+    SECTION("JsonVariant") {
+      doc["key"] = "hello";
+      REQUIRE(doc[doc["key"]] == "world");
+      REQUIRE(cdoc[cdoc["key"]] == "world");
+    }
+
     SECTION("supports operator|") {
       REQUIRE((doc["hello"] | "nope") == std::string("world"));
       REQUIRE((doc["world"] | "nope") == std::string("nope"));
@@ -31,8 +37,16 @@ TEST_CASE("JsonDocument::operator[]") {
   SECTION("array") {
     deserializeJson(doc, "[\"hello\",\"world\"]");
 
-    REQUIRE(doc[1] == "world");
-    REQUIRE(cdoc[1] == "world");
+    SECTION("int") {
+      REQUIRE(doc[1] == "world");
+      REQUIRE(cdoc[1] == "world");
+    }
+
+    SECTION("JsonVariant") {
+      doc[2] = 1;
+      REQUIRE(doc[doc[2]] == "world");
+      REQUIRE(cdoc[doc[2]] == "world");
+    }
   }
 }
 

extras/tests/JsonObject/containsKey.cpp

@@ -30,4 +30,10 @@ TEST_CASE("JsonObject::containsKey()") {
     REQUIRE(true == obj.containsKey(vla));
   }
 #endif
+
+  SECTION("key is a JsonVariant") {
+    doc["key"] = "hello";
+    REQUIRE(true == obj.containsKey(obj["key"]));
+    REQUIRE(false == obj.containsKey(obj["hello"]));
+  }
 }

extras/tests/JsonObject/remove.cpp

@@ -80,4 +80,10 @@ TEST_CASE("JsonObject::remove()") {
     JsonObject unboundObject;
     unboundObject.remove(unboundObject.begin());
   }
+
+  SECTION("remove(JsonVariant)") {
+    obj["key"] = "b";
+    obj.remove(obj["key"]);
+    REQUIRE("{\"a\":0,\"c\":2,\"key\":\"b\"}" == doc.as<std::string>());
+  }
 }

extras/tests/JsonObject/subscript.cpp

@@ -249,4 +249,12 @@ TEST_CASE("JsonObject::operator[]") {
     REQUIRE(true == obj["hello"]["world"].is<int>());
     REQUIRE(false == obj["hello"]["world"].is<bool>());
   }
+
+  SECTION("JsonVariant") {
+    obj["hello"] = "world";
+    doc["key"] = "hello";
+
+    REQUIRE(obj[obj["key"]] == "world");
+    REQUIRE(obj[obj["foo"]] == nullptr);
+  }
 }

extras/tests/JsonObjectConst/containsKey.cpp

@@ -29,4 +29,10 @@ TEST_CASE("JsonObjectConst::containsKey()") {
     REQUIRE(true == obj.containsKey(vla));
   }
 #endif
+
+  SECTION("supports JsonVariant") {
+    doc["key"] = "hello";
+    REQUIRE(true == obj.containsKey(obj["key"]));
+    REQUIRE(false == obj.containsKey(obj["hello"]));
+  }
 }

extras/tests/JsonObjectConst/subscript.cpp

@@ -30,4 +30,10 @@ TEST_CASE("JsonObjectConst::operator[]") {
     REQUIRE(std::string("world") == obj[vla]);
   }
 #endif
+
+  SECTION("supports JsonVariant") {
+    doc["key"] = "hello";
+    REQUIRE(obj[obj["key"]] == "world");
+    REQUIRE(obj[obj["foo"]] == nullptr);
+  }
 }

extras/tests/JsonVariant/containsKey.cpp

@@ -23,4 +23,12 @@ TEST_CASE("JsonVariant::containsKey()") {
     REQUIRE(var.containsKey(std::string("hello")) == true);
     REQUIRE(var.containsKey(std::string("world")) == false);
   }
+
+  SECTION("containsKey(JsonVariant)") {
+    var["hello"] = "world";
+    var["key"] = "hello";
+
+    REQUIRE(var.containsKey(doc["key"]) == true);
+    REQUIRE(var.containsKey(doc["foo"]) == false);
+  }
 }

extras/tests/JsonVariant/remove.cpp

@@ -81,3 +81,30 @@ TEST_CASE("JsonVariant::remove(std::string)") {
 
   REQUIRE(var.as<std::string>() == "{\"a\":1}");
 }
+
+TEST_CASE("JsonVariant::remove(JsonVariant) from object") {
+  JsonDocument doc;
+  JsonVariant var = doc.to<JsonVariant>();
+
+  var["a"] = "a";
+  var["b"] = 2;
+  var["c"] = "b";
+
+  var.remove(var["c"]);
+
+  REQUIRE(var.as<std::string>() == "{\"a\":\"a\",\"c\":\"b\"}");
+}
+
+TEST_CASE("JsonVariant::remove(JsonVariant) from array") {
+  JsonDocument doc;
+  JsonVariant var = doc.to<JsonVariant>();
+
+  var[0] = 3;
+  var[1] = 2;
+  var[2] = 1;
+
+  var.remove(var[2]);
+  var.remove(var[3]);  // noop
+
+  REQUIRE(var.as<std::string>() == "[3,1]");
+}

extras/tests/JsonVariant/subscript.cpp

@@ -67,6 +67,15 @@ TEST_CASE("JsonVariant::operator[]") {
       REQUIRE(var.is<int>());
       REQUIRE(var.as<int>() == 123);
     }
+
+    SECTION("use JsonVariant as index") {
+      array.add("A");
+      array.add("B");
+      array.add(1);
+
+      REQUIRE(var[var[2]] == "B");
+      REQUIRE(var[var[3]].isNull());
+    }
   }
 
   SECTION("The JsonVariant is a JsonObject") {
@@ -103,6 +112,15 @@ TEST_CASE("JsonVariant::operator[]") {
       JsonArray arr = var["hello"].to<JsonArray>();
       REQUIRE(arr.isNull() == false);
     }
+
+    SECTION("use JsonVariant as key") {
+      object["a"] = "a";
+      object["b"] = "b";
+      object["c"] = "b";
+
+      REQUIRE(var[var["c"]] == "b");
+      REQUIRE(var[var["d"]].isNull());
+    }
   }
 
 #if defined(HAS_VARIABLE_LENGTH_ARRAY) && \

extras/tests/JsonVariantConst/containsKey.cpp

@@ -30,4 +30,10 @@ TEST_CASE("JsonVariantConst::containsKey()") {
     REQUIRE(true == var.containsKey(vla));
   }
 #endif
+
+  SECTION("support JsonVariant") {
+    doc["key"] = "hello";
+    REQUIRE(var.containsKey(var["key"]) == true);
+    REQUIRE(var.containsKey(var["foo"]) == false);
+  }
 }

extras/tests/JsonVariantConst/subscript.cpp

@@ -27,13 +27,24 @@ TEST_CASE("JsonVariantConst::operator[]") {
     array.add("A");
     array.add("B");
 
-    REQUIRE(std::string("A") == var[0]);
-    REQUIRE(std::string("B") == var[1]);
-    REQUIRE(std::string("A") ==
-            var[static_cast<unsigned char>(0)]);  // issue #381
-    REQUIRE(var[666].isNull());
-    REQUIRE(var[3].isNull());
-    REQUIRE(var["0"].isNull());
+    SECTION("int") {
+      REQUIRE(std::string("A") == var[0]);
+      REQUIRE(std::string("B") == var[1]);
+      REQUIRE(std::string("A") ==
+              var[static_cast<unsigned char>(0)]);  // issue #381
+      REQUIRE(var[666].isNull());
+      REQUIRE(var[3].isNull());
+    }
+
+    SECTION("const char*") {
+      REQUIRE(var["0"].isNull());
+    }
+
+    SECTION("JsonVariant") {
+      array.add(1);
+      REQUIRE(var[var[2]] == std::string("B"));
+      REQUIRE(var[var[3]].isNull());
+    }
   }
 
   SECTION("object") {
@@ -64,5 +75,11 @@ TEST_CASE("JsonVariantConst::operator[]") {
       REQUIRE(std::string("A") == var[vla]);
     }
 #endif
+
+    SECTION("supports JsonVariant") {
+      object["c"] = "b";
+      REQUIRE(var[var["c"]] == "B");
+      REQUIRE(var[var["d"]].isNull());
+    }
   }
 }