json_path.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/json.h>
#include <optional>
#include <string>
#include <vector>
 
namespace neograph::llm {
 
using json = neograph::json;
 
namespace json_path {
 
inline std::vector<std::string> split_path(const std::string& path) {
    std::vector<std::string> segments;
    if (path.empty()) return segments;
 
    std::string::size_type start = 0;
    while (start < path.size()) {
        auto dot = path.find('.', start);
        if (dot == std::string::npos) {
            segments.push_back(path.substr(start));
            break;
        }
        segments.push_back(path.substr(start, dot - start));
        start = dot + 1;
    }
    return segments;
}
 
inline bool is_index(const std::string& s) {
    if (s.empty()) return false;
    for (char c : s) {
        if (c < '0' || c > '9') return false;
    }
    return true;
}
 
inline std::optional<json> at_path(const json& root, const std::string& path) {
    if (path.empty()) return root;
 
    auto segments = split_path(path);
    json current = root;
 
    for (const auto& seg : segments) {
        if (current.is_object()) {
            if (!current.contains(seg)) return std::nullopt;
            current = current[seg];
        } else if (current.is_array() && is_index(seg)) {
            size_t idx = std::stoul(seg);
            if (idx >= current.size()) return std::nullopt;
            current = current[idx];
        } else {
            return std::nullopt;
        }
    }
    return current;
}
 
inline bool has_path(const json& root, const std::string& path) {
    return at_path(root, path).has_value();
}
 
template<typename T>
inline T get_path(const json& root, const std::string& path, const T& default_val) {
    auto node = at_path(root, path);
    if (!node) return default_val;
    try {
        return node->template get<T>();
    } catch (...) {
        return default_val;
    }
}
 
namespace detail {
// Recursive walker that uses operator[] at each level. Each operator[]
// returns a write-through handle; the recursion hands that handle down
// by value (move), preserving parent info so mutations propagate upward.
inline void set_path_walk(json parent, const std::vector<std::string>& segs,
                          size_t i, const json& value) {
    if (i + 1 == segs.size()) {
        parent[segs[i]] = value;
        return;
    }
    set_path_walk(parent[segs[i]], segs, i + 1, value);
}
} // namespace detail
 
inline void set_path(json& root, const std::string& path, const json& value) {
    if (path.empty()) {
        root = value;
        return;
    }
    auto segments = split_path(path);
    if (segments.size() == 1) {
        root[segments[0]] = value;
        return;
    }
    detail::set_path_walk(root[segments[0]], segments, 1, value);
}
 
} // namespace json_path
} // namespace neograph::llm