as noted in CHANGES.md

Author: tyler-gilbert

CHANGES.md

@@ -2,6 +2,8 @@
 
 ## New Features
 
+- Add an iterator for `JsonObject` to support range-for loops
+- Add `find()` to `JsonValue` to find a sub-value based on a path e.g "top/[4]/next"
 - Add method `native_value()` to `JsonValue` which can be used for object tracing and debugging.
 
 ## Bug Fixes

library/include/json/Json.hpp

@@ -128,6 +128,9 @@ class JsonValue : public api::ExecutionContext {
     return m_value;
   }
 
+  JsonValue find(const var::StringView path, const char* delimiter = "/") const;
+
+
 protected:
   struct Key {
     Key(const var::StringView value)
@@ -146,6 +149,7 @@ class JsonValue : public api::ExecutionContext {
 
 private:
   friend class JsonDocument;
+  friend class JsonObjectIterator;
   friend class JsonObject;
   friend class JsonArray;
   friend class JsonTrue;
@@ -200,13 +204,58 @@ template <class Derived> class JsonKeyValueList : public var::Vector<Derived> {
   }
 };
 
+class JsonObjectIterator : private JsonApi {
+public:
+
+  JsonObjectIterator() = default;
+
+  JsonObjectIterator(json_t * value){
+    m_json_value = value;
+    m_json_iter = api()->object_iter(m_json_value);
+  }
+
+
+  bool operator!=(JsonObjectIterator const &a) const noexcept {
+    return m_json_iter != a.m_json_iter;
+  }
+
+  JsonObject operator*() const noexcept;
+
+  JsonObjectIterator &operator++() {
+    m_json_iter = api()->object_iter_next(m_json_value, m_json_iter);
+    return *this;
+  }
+
+
+private:
+  json_t * m_json_value = nullptr;
+  void * m_json_iter = nullptr;
+};
+
 class JsonObject : public JsonValue {
 public:
   JsonObject();
 
   JsonObject(const JsonObject &value);
   JsonObject &operator=(const JsonObject &value);
 
+
+  JsonObjectIterator begin() const noexcept {
+    return JsonObjectIterator(m_value);
+  }
+
+  JsonObjectIterator end() const noexcept {
+    return JsonObjectIterator(nullptr);
+  }
+
+  JsonObjectIterator cbegin() const noexcept {
+    return JsonObjectIterator(m_value);
+  }
+
+  JsonObjectIterator cend() const noexcept {
+    return JsonObjectIterator(nullptr);
+  }
+
   template <class T> JsonKeyValueList<T> construct_key_list() {
     KeyList list = get_key_list();
     JsonKeyValueList<T> result;

library/src/Json.cpp

@@ -192,6 +192,12 @@ const JsonObject &JsonValue::to_object() const {
   return static_cast<const JsonObject &>(*this);
 }
 
+JsonObject JsonObjectIterator::operator*() const noexcept {
+  return JsonValue(m_json_value)
+    .to_object()
+    .at(api()->object_iter_key(m_json_iter));
+}
+
 JsonObject &JsonValue::to_object() { return static_cast<JsonObject &>(*this); }
 
 const JsonArray &JsonValue::to_array() const {
@@ -487,6 +493,82 @@ JsonValue JsonObject::at(const var::StringView key) const {
   return JsonValue(api()->object_get(m_value, Key(key).cstring));
 }
 
+JsonValue
+JsonValue::find(const var::StringView path, const char *delimiter) const {
+  const auto list = path.split(delimiter);
+  JsonValue current = *this;
+
+  auto get_offset_from_string = [](var::StringView item) {
+    return item.pop_back().pop_back().to_unsigned_long();
+  };
+
+  for (const auto item : list) {
+    if (item.is_empty()) {
+      API_RETURN_VALUE_ASSIGN_ERROR(JsonValue(), "empty item provided", EINVAL);
+      return JsonValue();
+    }
+
+    if (current.is_object()) {
+      auto next = current.to_object().at(item);
+      if (next.is_valid()) {
+        current = next;
+        continue;
+      }
+
+      if (item.at(0) == '{') {
+        const auto object_offset = get_offset_from_string(item);
+        size_t count = 0;
+        bool is_found = false;
+        for (const auto &value : current.to_object()) {
+          if (count == object_offset) {
+            current = value;
+            is_found = true;
+            break;
+          }
+          count++;
+        }
+        if (!is_found) {
+          API_RETURN_VALUE_ASSIGN_ERROR(
+            JsonValue(),
+            "didn't find {} offset",
+            EINVAL);
+        }
+      } else {
+        current = current.to_object().at(item);
+      }
+    } else if (current.is_array()) {
+      if (item.at(0) == '[') {
+        if (current.is_array() == false) {
+          API_RETURN_VALUE_ASSIGN_ERROR(JsonValue(), "not an array", EINVAL);
+        }
+        const auto array_offset = get_offset_from_string(item);
+        ;
+        if (current.to_array().count() <= array_offset) {
+          API_RETURN_VALUE_ASSIGN_ERROR(
+            JsonValue(),
+            "[] is beyond array",
+            EINVAL);
+        }
+        current = current.to_array().at(array_offset);
+      } else {
+        API_RETURN_VALUE_ASSIGN_ERROR(
+          JsonValue(),
+          "array not specified []",
+          EINVAL);
+        return JsonValue();
+      }
+    }
+    if( current.is_valid() == false ){
+      API_RETURN_VALUE_ASSIGN_ERROR(
+        JsonValue(),
+        "invalid path",
+        EINVAL);
+      return JsonValue();
+    }
+  }
+  return current;
+}
+
 JsonArray::JsonArray() { m_value = JsonArray::create(); }
 
 JsonArray::JsonArray(const JsonArray &value) { add_reference(value.m_value); }