walk.h

Go to the documentation of this file.

#pragma once
 
#include <parcel/cell.h>
#include <parcel/list.h>
#include <parcel/map.h>
#include <parcel/struct.h>
#include <parcel/union.h>
 
#include <string>
#include <utility>
#include <vector>
 
#if defined(__cpp_lib_generator) && __cpp_lib_generator >= 202207L
#include <generator>
#define PARCEL_HAS_GENERATOR 1
#else
#define PARCEL_HAS_GENERATOR 0
#endif
 
namespace parcel {
 
struct WalkEntry {
    std::string path;
    cell_t cell;
};
 
namespace detail {
 
// Escape a path component per RFC 6901: '~' -> "~0", '/' -> "~1". Order
// matters — '~' must be substituted before '/' so the substituted '/' is
// not double-escaped on the next pass.
inline std::string jp_escape(const std::string_view k) {
    std::string out;
    out.reserve(k.size());
    for (const char c : k) {
        if (c == '~') {
            out += "~0";
        } else if (c == '/') {
            out += "~1";
        } else {
            out += c;
        }
    }
    return out;
}
 
inline void walk_collect(cell_t const& root, const std::string& path, std::vector<WalkEntry>& out) {
    if (!root) {
        return;
    }
    out.push_back({path, root});
 
    if (auto const* list = dynamic_cast<ListCell const*>(root.get()); list != nullptr) {
        std::size_t i = 0;
        for (auto const& el : list->value) {
            std::string sub = path;
            sub += '/';
            sub += std::to_string(i);
            walk_collect(el, sub, out);
            ++i;
        }
        return;
    }
 
    if (auto const* map = dynamic_cast<MapCell const*>(root.get()); map != nullptr) {
        for (auto const& [k, v] : map->value) {
            std::string sub = path;
            sub += '/';
            sub += jp_escape(k);
            walk_collect(v, sub, out);
        }
        return;
    }
}
 
}  // namespace detail
 
[[nodiscard]] inline std::vector<WalkEntry> walk_to_vector(cell_t const& root) {
    std::vector<WalkEntry> out;
    detail::walk_collect(root, "", out);
    return out;
}
 
#if PARCEL_HAS_GENERATOR
namespace detail {
 
// Recursive coroutine helper for `walk`. Mirrors `walk_collect`'s contract
// but yields each node lazily as the consumer pulls — no full materialization.
inline std::generator<WalkEntry> walk_node(cell_t root, std::string path) {
    if (!root) {
        co_return;
    }
    co_yield WalkEntry{path, root};
 
    if (auto const* list = dynamic_cast<ListCell const*>(root.get()); list != nullptr) {
        std::size_t i = 0;
        for (auto const& el : list->value) {
            std::string sub = path;
            sub += '/';
            sub += std::to_string(i);
            for (auto&& entry : walk_node(el, std::move(sub))) {
                co_yield std::move(entry);
            }
            ++i;
        }
        co_return;
    }
 
    if (auto const* map = dynamic_cast<MapCell const*>(root.get()); map != nullptr) {
        for (auto const& [k, v] : map->value) {
            std::string sub = path;
            sub += '/';
            sub += jp_escape(k);
            for (auto&& entry : walk_node(v, std::move(sub))) {
                co_yield std::move(entry);
            }
        }
        co_return;
    }
}
 
}  // namespace detail
 
inline std::generator<WalkEntry> walk(cell_t root) {
    return detail::walk_node(std::move(root), "");
}
#endif
 
}  // namespace parcel