43 static small test(
decltype(&C::fromJSON));
48 static const bool value =
sizeof(test<T>(0)) ==
sizeof(
char);
51 using NodeReferences = std::unordered_map<int, IR::Node *>;
52 std::shared_ptr<NodeReferences> node_refs;
53 std::unique_ptr<JsonData> json_root;
56 std::unique_ptr<absl::flat_hash_set<P4::cstring, Util::Hash>> decoded;
57 bool (*errfn)(
const JSONLoader &, std::string_view msg) =
nullptr;
59 JSONLoader(
const JsonData *
json, std::shared_ptr<NodeReferences> refs,
61 : node_refs(std::move(refs)),
json(
json), locinfo(locinfo) {}
65 : node_refs(std::make_shared<NodeReferences>()), locinfo(li) {
67 json = json_root.get();
70 JSONLoader(
const JSONLoader &unpacker, std::string_view field)
71 : node_refs(unpacker.node_refs),
json(
nullptr), locinfo(unpacker.locinfo) {
72 if (!unpacker)
return;
74 if (
auto it = obj->find(field); it != obj->end()) {
75 if (unpacker.decoded) unpacker.decoded->emplace(field);
76 json = it->second.get();
81 explicit operator bool()
const {
return json !=
nullptr; }
83 [[nodiscard]]
bool is()
const {
87 [[nodiscard]]
const T &as()
const {
88 if (!is<T>()) error(
"type mismatch in json");
92 [[nodiscard]]
const T *to()
const {
93 return json ?
json->to<T>() :
nullptr;
96 std::string locdesc(
const JsonData &d)
const {
97 if (!locinfo)
return "";
98 return locinfo->desc(d);
100 std::string locdesc()
const {
101 if (!
json)
return "";
102 return locdesc(*
json);
104 std::string locdesc(std::string_view field)
const {
105 if (!locinfo || !
json)
return "";
107 if (
auto it = obj->find(field); it != obj->end())
return locinfo->desc(*it->second);
111 bool error(std::string_view msg)
const {
116 void track_decode() {
117 BUG_CHECK(
json &&
json->is<
JsonObject>(),
"JSONLoader::track_decode on non-JsonObject");
118 if (!decoded) decoded = std::make_unique<absl::flat_hash_set<P4::cstring, Util::Hash>>();
121 template <
typename FN>
122 void undecoded(FN fn) {
123 BUG_CHECK(decoded,
"Called JSONLoader::undecoded without track_decode");
125 if (!decoded->count(el.first)) fn(*
this, el.first, *el.second);
129 const IR::Node *get_node(NodeFactoryFn factory =
nullptr) {
131 error(
"node is not a JsonObject");
136 auto success = load(
"Node_ID",
id) || error(
"missing field Node_ID");
137 if (!success)
return nullptr;
139 if (node_refs->find(
id) == node_refs->end()) {
142 auto success = load(
"Node_Type", type) || error(
"missing field Node_Type");
143 if (!success)
return nullptr;
144 factory = get(IR::unpacker_table, type);
147 auto *node = factory(*this)->to<
IR::Node>();
149 node_refs->emplace(
id, node);
153 node->sourceInfoFromJSON(*
this);
155 error(
"no Node factory for " + type);
159 return node_refs->at(
id);
161 error(
"invalid Node_ID " + std::to_string(
id));
165 template <
typename T>
169 for (
auto &e : as<JsonVector>()) {
175 template <
typename T>
176 void unpack_json(std::set<T> &v) {
179 for (
auto &e : as<JsonVector>()) {
185 template <
typename T>
189 for (
auto &e : as<JsonVector>()) {
195 template <
typename T>
197 v = get_node(NodeFactoryFn(&IR::Vector<T>::fromJSON))->
as<
IR::Vector<T>>();
199 template <
typename T>
201 v = get_node(NodeFactoryFn(&IR::Vector<T>::fromJSON))->checkedTo<
IR::Vector<T>>();
203 template <
typename T>
207 template <
typename T>
209 v = get_node(NodeFactoryFn(&IR::IndexedVector<T>::fromJSON))
212 template <
class T,
template <
class K,
class V,
class COMP,
class ALLOC>
class MAP,
class COMP,
215 m = get_node(NodeFactoryFn(&IR::NameMap<T, MAP, COMP, ALLOC>::fromJSON))
218 template <
class T,
template <
class K,
class V,
class COMP,
class ALLOC>
class MAP,
class COMP,
221 m = get_node(NodeFactoryFn(&IR::NameMap<T, MAP, COMP, ALLOC>::fromJSON))
225 template <
typename K,
typename V>
226 void unpack_json(std::map<K, V> &v) {
227 std::pair<K, V> temp;
229 if (is<JsonVector>()) {
230 for (
auto &e : as<JsonVector>()) {
235 for (
auto &e : as<JsonObject>()) {
237 load(e.second, temp.second);
242 template <
typename K,
typename V>
244 std::pair<K, V> temp;
246 if (is<JsonVector>()) {
247 for (
auto &e : as<JsonVector>()) {
252 for (
auto &e : as<JsonObject>()) {
254 load(e.second, temp.second);
259 template <
typename V>
261 std::pair<cstring, V> temp;
263 for (
auto &e : as<JsonObject>()) {
264 temp.first = e.first;
265 load(e.second, temp.second);
270 template <
typename K,
typename V>
271 void unpack_json(std::multimap<K, V> &v) {
272 std::pair<K, V> temp;
274 if (is<JsonVector>()) {
275 for (
auto &e : as<JsonVector>()) {
280 for (
auto &e : as<JsonObject>()) {
282 load(e.second, temp.second);
288 template <
typename T>
289 void unpack_json(std::vector<T> &v) {
292 for (
auto &e : as<JsonVector>()) {
298 template <
typename T,
typename U>
299 void unpack_json(std::pair<T, U> &v) {
300 load(
"first", v.first) || error(
"missing field first");
301 load(
"second", v.second) || error(
"missing field second");
304 template <
typename T>
305 void unpack_json(std::optional<T> &v) {
306 bool isValid =
false;
307 load(
"valid", isValid) || error(
"missing field valid");
313 auto success = load(
"value", value) || error(
"missing field value");
318 v = std::move(value);
321 template <
int N,
class Variant>
322 std::enable_if_t<N == std::variant_size_v<Variant>> unpack_variant(
int ,
324 BUG(
"Error traversing variant during load");
327 template <
int N,
class Variant>
328 std::enable_if_t<(N < std::variant_size_v<Variant>)> unpack_variant(
int target,
331 variant.template emplace<N>();
332 load(
"value", std::get<N>(variant)) || error(
"missing field value");
334 unpack_variant<N + 1>(target, variant);
337 template <
class... Types>
338 void unpack_json(std::variant<Types...> &v) {
340 load(
"variant_index", index) || error(
"missing field variant_index");
341 unpack_variant<0>(index, v);
344 void unpack_json(
bool &v) { v = as<JsonBoolean>(); }
346 template <
typename T>
347 std::enable_if_t<std::is_integral_v<T>> unpack_json(T &v) {
349 v =
static_cast<T
>(as<JsonNumber>().val);
351 void unpack_json(big_int &v) { v = as<JsonNumber>().val; }
352 void unpack_json(std::string &v) {
353 if (is<JsonString>()) v = as<JsonString>();
356 if (is<JsonString>())
358 else if (is<JsonNull>())
361 void unpack_json(
IR::ID &v) {
369 error(
"bit matrix value not a string");
372 void unpack_json(
bitvec &v) {
376 error(
"bitvec value not a string");
379 template <
typename T>
380 std::enable_if_t<std::is_enum_v<T>> unpack_json(T &v) {
384 error(
"enum tag not a string");
391 error(
"match name not a string");
394 template <
typename T>
395 std::enable_if_t<has_fromJSON<T>::value && !std::is_base_of_v<IR::INode, T> &&
396 std::is_pointer_v<decltype(T::fromJSON(std::declval<JSONLoader &>()))>>
398 v = T::fromJSON(*
this);
401 template <
typename T>
402 std::enable_if_t<has_fromJSON<T>::value && !std::is_base_of_v<IR::INode, T> &&
403 std::is_pointer_v<decltype(T::fromJSON(std::declval<JSONLoader &>()))>>
405 v = *(T::fromJSON(*
this));
408 template <
typename T>
409 std::enable_if_t<has_fromJSON<T>::value && !std::is_base_of<IR::INode, T>::value &&
410 !std::is_pointer_v<decltype(T::fromJSON(std::declval<JSONLoader &>()))>>
412 v = T::fromJSON(*
this);
415 template <
typename T>
416 std::enable_if_t<has_fromJSON<T>::value && !std::is_base_of<IR::INode, T>::value &&
417 !std::is_pointer_v<decltype(T::fromJSON(std::declval<JSONLoader &>()))>>
419 v =
new T(T::fromJSON(*
this));
422 template <
typename T>
423 std::enable_if_t<std::is_base_of_v<IR::INode, T>> unpack_json(T &v) {
424 v = get_node()->as<T>();
426 template <
typename T>
427 std::enable_if_t<std::is_base_of_v<IR::INode, T>> unpack_json(
const T *&v) {
428 v = get_node()->checkedTo<T>();
431 template <
typename T,
size_t N>
432 void unpack_json(T (&v)[N]) {
434 for (
size_t i = 0; i < N && i < j->size(); ++i) {
435 load(j->at(i), v[i]);
441 template <
typename T>
443 JSONLoader(&
json, node_refs, locinfo).unpack_json(v);
446 template <
typename T>
447 void load(
const std::unique_ptr<JsonData> &
json, T &v) {
448 JSONLoader(
json.get(), node_refs, locinfo).unpack_json(v);
451 template <
typename T>
452 bool load(std::string_view field, T *&v) {
453 if (
auto loader = JSONLoader(*
this, field)) {
454 loader.unpack_json(v);
462 template <
typename T>
463 bool load(std::string_view field, T &v) {
464 if (
auto loader = JSONLoader(*
this, field)) {
465 loader.unpack_json(v);
471 template <
typename T>
472 JSONLoader &operator>>(T &v) {