osb/source/core/StarJsonPath.hpp

330 lines
12 KiB
C++
Raw Permalink Normal View History

#pragma once
2023-06-20 04:33:09 +00:00
#include "StarLexicalCast.hpp"
#include "StarJson.hpp"
namespace Star {
namespace JsonPath {
enum class TypeHint {
Array,
Object
};
typedef function<TypeHint(String&, String const&, String::const_iterator&, String::const_iterator)> PathParser;
STAR_EXCEPTION(ParsingException, JsonException);
STAR_EXCEPTION(TraversalException, JsonException);
// Parses RFC 6901 JSON Pointers, e.g. /foo/bar/4/baz
TypeHint parsePointer(String& outputBuffer, String const& path, String::const_iterator& iterator, String::const_iterator end);
// Parses JavaScript-like paths, e.g. foo.bar[4].baz
TypeHint parseQueryPath(String& outputBuffer, String const& path, String::const_iterator& iterator, String::const_iterator end);
// Retrieves the portion of the Json document referred to by the given path.
template <typename Jsonlike>
Jsonlike pathGet(Jsonlike base, PathParser parser, String const& path);
// Find a given portion of the JSON document, if it exists. Instead of
// throwing a TraversalException if a portion of the path is invalid, simply
// returns nothing.
template <typename Jsonlike>
Maybe<Jsonlike> pathFind(Jsonlike base, PathParser parser, String const& path);
template <typename Jsonlike>
using JsonOp = function<Jsonlike(Jsonlike const&, Maybe<String> const&)>;
// Applies a function to the portion of the Json document referred to by the
// given path, returning the resulting new document. If the end of the path
// doesn't exist, the JsonOp is called with None, and its result will be
// inserted into the document. If the path already existed and the JsonOp
// returns None, it is erased. This is not as well-optimized as pathGet, but
// also not on the critical path for anything.
template <typename Jsonlike>
Jsonlike pathApply(Jsonlike const& base, PathParser parser, String const& path, JsonOp<Jsonlike> op);
// Sets a value on a Json document at the location referred to by path,
// returning the resulting new document.
template <typename Jsonlike>
Jsonlike pathSet(Jsonlike const& base, PathParser parser, String const& path, Jsonlike const& value);
// Erases the location referred to by the path from the document
template <typename Jsonlike>
Jsonlike pathRemove(Jsonlike const& base, PathParser parser, String const& path);
// Performs RFC6902 (JSON Patching) add operation. Inserts into arrays, or
// appends if the last path segment is "-". On objects, does the same as
// pathSet.
template <typename Jsonlike>
Jsonlike pathAdd(Jsonlike const& base, PathParser parser, String const& path, Jsonlike const& value);
template <typename Jsonlike>
using EmptyPathOp = function<Jsonlike(Jsonlike const&)>;
template <typename Jsonlike>
using ObjectOp = function<Jsonlike(Jsonlike const&, String const&)>;
template <typename Jsonlike>
using ArrayOp = function<Jsonlike(Jsonlike const&, Maybe<size_t>)>;
template <typename Jsonlike>
JsonOp<Jsonlike> genericObjectArrayOp(String path, EmptyPathOp<Jsonlike> emptyPathOp, ObjectOp<Jsonlike> objectOp, ArrayOp<Jsonlike> arrayOp);
STAR_CLASS(Path);
STAR_CLASS(Pointer);
STAR_CLASS(QueryPath);
class Path {
public:
Path(PathParser parser, String const& path) : m_parser(parser), m_path(path) {}
template <typename Jsonlike>
Jsonlike get(Jsonlike const& base) {
return pathGet(base, m_parser, m_path);
}
template <typename Jsonlike>
Jsonlike apply(Jsonlike const& base, JsonOp<Jsonlike> op) {
return pathApply(base, m_parser, m_path, op);
}
template <typename Jsonlike>
Jsonlike apply(Jsonlike const& base,
EmptyPathOp<Jsonlike> emptyPathOp,
ObjectOp<Jsonlike> objectOp,
ArrayOp<Jsonlike> arrayOp) {
JsonOp<Jsonlike> combinedOp = genericObjectArrayOp(m_path, emptyPathOp, objectOp, arrayOp);
return pathApply(base, m_parser, m_path, combinedOp);
}
template <typename Jsonlike>
Jsonlike set(Jsonlike const& base, Jsonlike const& value) {
return pathSet(base, m_parser, m_path, value);
}
template <typename Jsonlike>
Jsonlike remove(Jsonlike const& base) {
return pathRemove(base, m_parser, m_path);
}
template <typename Jsonlike>
Jsonlike add(Jsonlike const& base, Jsonlike const& value) {
return pathAdd(base, m_parser, m_path, value);
}
String const& path() const {
return m_path;
}
private:
PathParser m_parser;
String m_path;
};
class Pointer : public Path {
public:
Pointer(String const& path) : Path(parsePointer, path) {}
};
class QueryPath : public Path {
public:
QueryPath(String const& path) : Path(parseQueryPath, path) {}
};
template <typename Jsonlike>
Jsonlike pathGet(Jsonlike value, PathParser parser, String const& path) {
String buffer;
buffer.reserve(path.size());
auto pos = path.begin();
while (pos != path.end()) {
parser(buffer, path, pos, path.end());
if (value.type() == Json::Type::Array) {
if (buffer == "-")
2023-06-27 10:23:44 +00:00
throw TraversalException::format("Tried to get key '{}' in non-object type in pathGet(\"{}\")", buffer, path);
2023-06-20 04:33:09 +00:00
Maybe<size_t> i = maybeLexicalCast<size_t>(buffer);
if (!i)
2023-06-27 10:23:44 +00:00
throw TraversalException::format("Cannot parse '{}' as index in pathGet(\"{}\")", buffer, path);
2023-06-20 04:33:09 +00:00
if (*i < value.size())
value = value.get(*i);
else
2023-06-27 10:23:44 +00:00
throw TraversalException::format("Index {} out of range in pathGet(\"{}\")", buffer, path);
2023-06-20 04:33:09 +00:00
} else if (value.type() == Json::Type::Object) {
if (value.contains(buffer))
value = value.get(buffer);
else
2023-06-27 10:23:44 +00:00
throw TraversalException::format("No such key '{}' in pathGet(\"{}\")", buffer, path);
2023-06-20 04:33:09 +00:00
} else {
2023-06-27 10:23:44 +00:00
throw TraversalException::format("Tried to get key '{}' in non-object type in pathGet(\"{}\")", buffer, path);
2023-06-20 04:33:09 +00:00
}
}
return value;
}
template <typename Jsonlike>
Maybe<Jsonlike> pathFind(Jsonlike value, PathParser parser, String const& path) {
String buffer;
buffer.reserve(path.size());
auto pos = path.begin();
while (pos != path.end()) {
parser(buffer, path, pos, path.end());
if (value.type() == Json::Type::Array) {
if (buffer == "-")
return {};
Maybe<size_t> i = maybeLexicalCast<size_t>(buffer);
if (i && *i < value.size())
value = value.get(*i);
else
return {};
} else if (value.type() == Json::Type::Object) {
if (value.contains(buffer))
value = value.get(buffer);
else
return {};
} else {
return {};
}
}
return value;
}
template <typename Jsonlike>
Jsonlike pathApply(String& buffer,
Jsonlike const& value,
PathParser parser,
String const& path,
String::const_iterator const current,
JsonOp<Jsonlike> op) {
if (current == path.end())
return op(value, {});
String::const_iterator iterator = current;
parser(buffer, path, iterator, path.end());
if (value.type() == Json::Type::Array) {
if (iterator == path.end()) {
return op(value, buffer);
} else {
Maybe<size_t> i = maybeLexicalCast<size_t>(buffer);
if (!i)
2023-06-27 10:23:44 +00:00
throw TraversalException::format("Cannot parse '{}' as index in pathApply(\"{}\")", buffer, path);
2023-06-20 04:33:09 +00:00
if (*i >= value.size())
2023-06-27 10:23:44 +00:00
throw TraversalException::format("Index {} out of range in pathApply(\"{}\")", buffer, path);
2023-06-20 04:33:09 +00:00
return value.set(*i, pathApply(buffer, value.get(*i), parser, path, iterator, op));
}
} else if (value.type() == Json::Type::Object) {
if (iterator == path.end()) {
return op(value, buffer);
} else {
if (!value.contains(buffer))
2023-06-27 10:23:44 +00:00
throw TraversalException::format("No such key '{}' in pathApply(\"{}\")", buffer, path);
2023-06-20 04:33:09 +00:00
Jsonlike newChild = pathApply(buffer, value.get(buffer), parser, path, iterator, op);
iterator = current;
// pathApply just mutated buffer. Recover the current path component:
parser(buffer, path, iterator, path.end());
return value.set(buffer, newChild);
}
} else {
2023-06-27 10:23:44 +00:00
throw TraversalException::format("Tried to get key '{}' in non-object type in pathApply(\"{}\")", buffer, path);
2023-06-20 04:33:09 +00:00
}
}
template <typename Jsonlike>
Jsonlike pathApply(Jsonlike const& base, PathParser parser, String const& path, JsonOp<Jsonlike> op) {
String buffer;
return pathApply(buffer, base, parser, path, path.begin(), op);
}
template <typename Jsonlike>
JsonOp<Jsonlike> genericObjectArrayOp(String path, EmptyPathOp<Jsonlike> emptyPathOp, ObjectOp<Jsonlike> objectOp, ArrayOp<Jsonlike> arrayOp) {
return [=](Jsonlike const& parent, Maybe<String> const& key) -> Jsonlike {
if (key.isNothing())
return emptyPathOp(parent);
if (parent.type() == Json::Type::Array) {
if (*key == "-")
return arrayOp(parent, {});
Maybe<size_t> i = maybeLexicalCast<size_t>(*key);
if (!i)
2023-06-27 10:23:44 +00:00
throw TraversalException::format("Cannot parse '{}' as index in Json path \"{}\"", *key, path);
2023-06-20 04:33:09 +00:00
if (i && *i > parent.size())
2023-06-27 10:23:44 +00:00
throw TraversalException::format("Index {} out of range in Json path \"{}\"", *key, path);
2023-06-20 04:33:09 +00:00
if (i && *i == parent.size())
i = {};
return arrayOp(parent, i);
} else if (parent.type() == Json::Type::Object) {
return objectOp(parent, *key);
} else {
2023-06-27 10:23:44 +00:00
throw TraversalException::format("Tried to set key '{}' in non-object type in pathSet(\"{}\")", *key, path);
2023-06-20 04:33:09 +00:00
}
};
}
template <typename Jsonlike>
Jsonlike pathSet(Jsonlike const& base, PathParser parser, String const& path, Jsonlike const& value) {
EmptyPathOp<Jsonlike> emptyPathOp = [&value](Jsonlike const&) {
return value;
};
ObjectOp<Jsonlike> objectOp = [&value](Jsonlike const& object, String const& key) {
return object.set(key, value);
};
ArrayOp<Jsonlike> arrayOp = [&value](Jsonlike const& array, Maybe<size_t> i) {
if (i.isValid())
return array.set(*i, value);
return array.append(value);
};
return pathApply(base, parser, path, genericObjectArrayOp(path, emptyPathOp, objectOp, arrayOp));
}
template <typename Jsonlike>
Jsonlike pathRemove(Jsonlike const& base, PathParser parser, String const& path) {
EmptyPathOp<Jsonlike> emptyPathOp = [](Jsonlike const&) { return Json{}; };
ObjectOp<Jsonlike> objectOp = [](Jsonlike const& object, String const& key) {
if (!object.contains(key))
2023-06-27 10:23:44 +00:00
throw TraversalException::format("Could not find \"{}\" to remove", key);
2023-06-20 04:33:09 +00:00
return object.eraseKey(key);
};
ArrayOp<Jsonlike> arrayOp = [](Jsonlike const& array, Maybe<size_t> i) {
if (i.isValid())
return array.eraseIndex(*i);
throw TraversalException("Could not remove element after end of array");
};
return pathApply(base, parser, path, genericObjectArrayOp(path, emptyPathOp, objectOp, arrayOp));
}
template <typename Jsonlike>
Jsonlike pathAdd(Jsonlike const& base, PathParser parser, String const& path, Jsonlike const& value) {
EmptyPathOp<Jsonlike> emptyPathOp = [&value](Jsonlike const& document) {
if (document.type() == Json::Type::Null)
return value;
throw JsonException("Cannot add a value to the entire document, it is not empty.");
};
ObjectOp<Jsonlike> objectOp = [&value](Jsonlike const& object, String const& key) {
return object.set(key, value);
};
ArrayOp<Jsonlike> arrayOp = [&value](Jsonlike const& array, Maybe<size_t> i) {
if (i.isValid())
return array.insert(*i, value);
return array.append(value);
};
return pathApply(base, parser, path, genericObjectArrayOp(path, emptyPathOp, objectOp, arrayOp));
}
}
}