Added the ability to erase elements from a JSON array or object.

Author: stgates

Release/include/cpprest/json.h

@@ -564,6 +564,18 @@ namespace json
         CASABLANCA_DEPRECATED("This API is deprecated and will be removed in a future release, use json::value::at() instead.")
         value get(const utility::string_t &key) const;
 
+        /// <summary>
+        /// Erases an element of a JSON array. Throws if index is out of bounds.
+        /// </summary>
+        /// <param name="index">The index of the element to erase in the JSON array.</param>
+        _ASYNCRTIMP void erase(size_t index);
+
+        /// <summary>
+        /// Erases an element of a JSON object. Throws if the key doesn't exist.
+        /// </summary>
+        /// <param name="key">The key of the element to erase in the JSON object.</param>
+        _ASYNCRTIMP void erase(const utility::string_t &key);
+
         /// <summary>
         /// Accesses an element of a JSON array. Throws when index out of bounds.
         /// </summary>
@@ -864,6 +876,28 @@ namespace json
             return m_elements.crend();
         }
 
+        /// <summary>
+        /// Deletes an element of the JSON array.
+        /// </summary>
+        /// <param name="position">A const_iterator to the element to delete.</param>
+        void erase(const_iterator position)
+        {
+            m_elements.erase(position);
+        }
+
+        /// <summary>
+        /// Deletes the element at an index of the JSON array.
+        /// </summary>
+        /// <param name="index">The index of the element to delete.</param>
+        void erase(size_type index)
+        {
+            if (index >= m_elements.size())
+            {
+                throw json_exception(_XPLATSTR("index out of bounds"));
+            }
+            m_elements.erase(m_elements.begin() + index);
+        }
+
         /// <summary>
         /// Accesses an element of a JSON array. Throws when index out of bounds.
         /// </summary>
@@ -1056,6 +1090,30 @@ namespace json
             return m_elements.crend();
         }
 
+        /// <summary>
+        /// Deletes an element of the JSON object.
+        /// </summary>
+        /// <param name="position">A const_iterator to the element to delete.</param>
+        void erase(const_iterator position)
+        {
+            m_elements.erase(position);
+        }
+
+        /// <summary>
+        /// Deletes an element of the JSON object. If the key doesn't exist, this method throws.
+        /// </summary>
+        /// <param name="key">The key of an element in the JSON object.</param>
+        void erase(const utility::string_t &key)
+        {
+            auto iter = find_by_key(key);
+            if (iter == m_elements.end() || key != (iter->first))
+            {
+                throw web::json::json_exception(_XPLATSTR("Key not found"));
+            }
+
+            m_elements.erase(iter);
+        }
+
         /// <summary>
         /// Accesses an element of a JSON object. If the key doesn't exist, this method throws.
         /// </summary>

Release/src/json/json.cpp

@@ -425,6 +425,16 @@ bool json::value::operator==(const json::value &other) const
     __assume(0);
 }
 
+void web::json::value::erase(size_t index)
+{
+    return this->as_array().erase(index);
+}
+
+void web::json::value::erase(const utility::string_t &key)
+{
+    return this->as_object().erase(key);
+}
+
 // at() overloads
 web::json::value& web::json::value::at(size_t index)
 {

Release/tests/functional/json/to_as_and_operators_tests.cpp

@@ -331,6 +331,86 @@ TEST(negative_as_tests)
     VERIFY_THROWS(i.as_string(), json::json_exception);
 }
 
+TEST(erase_array_index)
+{
+    json::value a = json::value::array(4);
+    a[0] = json::value(1);
+    a[1] = json::value(2);
+    a[2] = json::value(3);
+    a[3] = json::value(4);
+
+    a.erase(1);
+    VERIFY_ARE_EQUAL(3, a.size());
+    VERIFY_ARE_EQUAL(1, a[0].as_integer());
+    VERIFY_ARE_EQUAL(3, a[1].as_integer());
+    VERIFY_ARE_EQUAL(4, a[2].as_integer());
+    a.as_array().erase(2);
+    VERIFY_ARE_EQUAL(2, a.size());
+    VERIFY_ARE_EQUAL(1, a[0].as_integer());
+    VERIFY_ARE_EQUAL(3, a[1].as_integer());
+}
+
+TEST(erase_array_iter)
+{
+    json::value a = json::value::array(3);
+    a[0] = json::value(1);
+    a[1] = json::value(2);
+    a[2] = json::value(3);
+
+    auto iter = a.as_array().begin() + 1;
+    a.as_array().erase(iter);
+    VERIFY_ARE_EQUAL(2, a.size());
+    VERIFY_ARE_EQUAL(1, a[0].as_integer());
+    VERIFY_ARE_EQUAL(3, a[1].as_integer());
+
+    auto citer = a.as_array().cbegin() + 1;
+    a.as_array().erase(citer);
+    VERIFY_ARE_EQUAL(1, a.size());
+    VERIFY_ARE_EQUAL(1, a[0].as_integer());
+}
+
+TEST(erase_object_key)
+{
+    auto o = json::value::object();
+    o[U("a")] = json::value(1);
+    o[U("b")] = json::value(2);
+    o[U("c")] = json::value(3);
+    o[U("d")] = json::value(4);
+
+    o.erase(U("a"));
+    VERIFY_ARE_EQUAL(3, o.size());
+    VERIFY_ARE_EQUAL(2, o[U("b")].as_integer());
+    VERIFY_ARE_EQUAL(3, o[U("c")].as_integer());
+    VERIFY_ARE_EQUAL(4, o[U("d")].as_integer());
+
+    o.as_object().erase(U("d"));
+    VERIFY_ARE_EQUAL(2, o.size());
+    VERIFY_ARE_EQUAL(2, o[U("b")].as_integer());
+    VERIFY_ARE_EQUAL(3, o[U("c")].as_integer());
+}
+
+TEST(erase_object_iter)
+{
+    auto o = json::value::object();
+    o[U("a")] = json::value(1);
+    o[U("b")] = json::value(2);
+    o[U("c")] = json::value(3);
+    o[U("d")] = json::value(4);
+
+    auto iter = o.as_object().begin() + 1;
+    o.as_object().erase(iter);
+    VERIFY_ARE_EQUAL(3, o.size());
+    VERIFY_ARE_EQUAL(1, o[U("a")].as_integer());
+    VERIFY_ARE_EQUAL(3, o[U("c")].as_integer());
+    VERIFY_ARE_EQUAL(4, o[U("d")].as_integer());
+
+    auto citer = o.as_object().begin() + 2;
+    o.as_object().erase(citer);
+    VERIFY_ARE_EQUAL(2, o.size());
+    VERIFY_ARE_EQUAL(1, o[U("a")].as_integer());
+    VERIFY_ARE_EQUAL(3, o[U("c")].as_integer());
+}
+
 TEST(floating_number_serialize)
 {
     // This number will have the longest serializaton possible (lenght of the string):