Reduce number of hashes in JSON-LD output (#905)

Signed-off-by: Juan Cruz Viotti <jv@jviotti.com>

Author: jviotti

src/output/output_jsonld.cc

@@ -4,39 +4,27 @@
 #include <sourcemeta/core/jsonpointer.h>
 #include <sourcemeta/core/uri.h>
 
-#include <algorithm>     // std::ranges::sort, std::ranges::any_of
-#include <functional>    // std::ref
-#include <tuple>         // std::tie
-#include <unordered_map> // std::unordered_map
-#include <utility>       // std::move
-#include <variant>       // std::variant, std::get, std::holds_alternative
-#include <vector>        // std::vector
+#include <algorithm>  // std::ranges::sort, std::ranges::any_of
+#include <functional> // std::ref
+#include <tuple>      // std::tie
+#include <utility>    // std::move
+#include <variant>    // std::variant, std::get, std::holds_alternative
+#include <vector>     // std::vector
 
 namespace {
 
-// The JSON-LD facts accumulated at one instance location, before a descriptor
-// kind is derived from the instance value shape.
-struct Facts {
-  std::vector<sourcemeta::core::JSONLDEdge> edges;
-  std::vector<sourcemeta::core::JSON::String> types;
-};
-
-using Accumulator = std::unordered_map<sourcemeta::core::WeakPointer, Facts,
-                                       sourcemeta::core::WeakPointer::Hasher>;
-
 // Default the undescribed elements of a collection: a scalar becomes a native
 // literal, and a nested array becomes an inner (unordered) collection, whose
 // own elements are filled the same way. As unordered collections, nested arrays
-// flatten into their parent during materialization. Elements that carry their
-// own annotations already have an accumulator entry and are left untouched.
+// flatten into their parent during materialization. Elements that already carry
+// a descriptor are left untouched.
 auto fill_collection(sourcemeta::core::JSONLDWeakAnnotationMap &map,
-                     const Accumulator &accumulator,
                      const sourcemeta::core::WeakPointer &pointer,
                      const sourcemeta::core::JSON &array) -> void {
   for (std::size_t index = 0; index < array.size(); index += 1) {
     auto element_pointer{pointer};
     element_pointer.push_back(index);
-    if (accumulator.contains(element_pointer)) {
+    if (map.contains(element_pointer)) {
       continue;
     }
 
@@ -46,7 +34,7 @@ auto fill_collection(sourcemeta::core::JSONLDWeakAnnotationMap &map,
           element_pointer,
           sourcemeta::core::JSONLDDescriptor{
               .edges = {}, .value = sourcemeta::core::JSONLDCollection{}});
-      fill_collection(map, accumulator, element_pointer, element);
+      fill_collection(map, element_pointer, element);
     } else if (!element.is_object()) {
       map.emplace(std::move(element_pointer),
                   sourcemeta::core::JSONLDDescriptor{
@@ -99,7 +87,12 @@ auto resolve(const sourcemeta::core::JSON &instance,
              const sourcemeta::blaze::SimpleOutput &output)
     -> std::variant<sourcemeta::core::JSONLDWeakAnnotationMap,
                     sourcemeta::blaze::JSONLDResolutionError> {
-  Accumulator accumulator;
+  // Accumulate straight into the descriptor map so that each instance location
+  // is hashed once, rather than once into a scratch map and again into the
+  // output. Edges and provisional types land on the default node descriptor;
+  // the second pass settles the descriptor kind once the value shape is known.
+  sourcemeta::core::JSONLDWeakAnnotationMap map;
+  map.reserve(output.annotations().size());
 
   for (const auto &[location, values] : output.annotations()) {
     if (location.evaluate_path.empty()) {
@@ -108,13 +101,13 @@ auto resolve(const sourcemeta::core::JSON &instance,
 
     const auto &keyword{location.evaluate_path.back().to_property()};
     // Only the keywords resolved below may contribute facts. An unhandled
-    // keyword must not create an accumulator entry, as the empty facts would
-    // otherwise materialize a spurious node or literal descriptor
+    // keyword must not create a map entry, as the empty facts would otherwise
+    // materialize a spurious node or literal descriptor
     if (keyword != "x-jsonld-id" && keyword != "x-jsonld-type") {
       continue;
     }
 
-    auto &facts{accumulator[location.instance_location]};
+    auto &descriptor{map[location.instance_location]};
     if (keyword == "x-jsonld-id") {
       for (const auto &value : values) {
         if (!is_iri_value(value)) {
@@ -125,43 +118,49 @@ auto resolve(const sourcemeta::core::JSON &instance,
               .message = "The value of x-jsonld-id must be an absolute IRI"};
         }
 
-        add_edge(facts.edges, value.to_string(), false);
+        add_edge(descriptor.edges, value.to_string(), false);
       }
     } else if (keyword == "x-jsonld-type") {
+      auto &types{
+          std::get<sourcemeta::core::JSONLDNode>(descriptor.value).types};
       for (const auto &value : values) {
         if (value.is_array()) {
           for (const auto &element : value.as_array()) {
             if (!is_iri_value(element)) {
               return type_iri_error(location.instance_location);
             }
 
-            add_type(facts.types, element.to_string());
+            add_type(types, element.to_string());
           }
         } else {
           if (!is_iri_value(value)) {
             return type_iri_error(location.instance_location);
           }
 
-          add_type(facts.types, value.to_string());
+          add_type(types, value.to_string());
         }
       }
     }
   }
 
-  sourcemeta::core::JSONLDWeakAnnotationMap map;
-  for (auto &[pointer, facts] : accumulator) {
-    std::ranges::sort(facts.edges,
+  // Settle each descriptor in place, so no location is hashed a second time,
+  // and note the array locations whose undescribed elements must be filled once
+  // the map is no longer being iterated.
+  std::vector<sourcemeta::core::WeakPointer> collections;
+  for (auto &[pointer, descriptor] : map) {
+    std::ranges::sort(descriptor.edges,
                       [](const sourcemeta::core::JSONLDEdge &left,
                          const sourcemeta::core::JSONLDEdge &right) -> bool {
                         return std::tie(left.predicate, left.reverse) <
                                std::tie(right.predicate, right.reverse);
                       });
-    std::ranges::sort(facts.types);
+    auto &types{std::get<sourcemeta::core::JSONLDNode>(descriptor.value).types};
+    std::ranges::sort(types);
 
     const auto &value{sourcemeta::core::get(instance, pointer)};
 
     // A type denotes an rdf:type, which only a node can carry
-    if (!value.is_object() && !facts.types.empty()) {
+    if (!value.is_object() && !types.empty()) {
       return sourcemeta::blaze::JSONLDResolutionError{
           .instance_location = sourcemeta::core::to_pointer(pointer),
           .facet = sourcemeta::blaze::JSONLDFacet::Type,
@@ -173,7 +172,7 @@ auto resolve(const sourcemeta::core::JSON &instance,
     // an array element (an index token) inherits the enclosing edge, so a
     // predicate on either is an error. A type on such a position is fine when
     // it is a node.
-    if (!facts.edges.empty() &&
+    if (!descriptor.edges.empty() &&
         (pointer.empty() || !pointer.back().is_property())) {
       return sourcemeta::blaze::JSONLDResolutionError{
           .instance_location = sourcemeta::core::to_pointer(pointer),
@@ -185,22 +184,18 @@ auto resolve(const sourcemeta::core::JSON &instance,
                            "element"};
     }
 
-    sourcemeta::core::JSONLDDescriptor descriptor;
-    descriptor.edges = std::move(facts.edges);
-    if (value.is_object()) {
-      descriptor.value =
-          sourcemeta::core::JSONLDNode{.types = std::move(facts.types)};
-    } else if (value.is_array()) {
+    // The descriptor already carries a node with the collected types; only the
+    // non-object shapes need their kind corrected.
+    if (value.is_array()) {
       descriptor.value = sourcemeta::core::JSONLDCollection{};
-    } else {
+      collections.push_back(pointer);
+    } else if (!value.is_object()) {
       descriptor.value = sourcemeta::core::JSONLDLiteral{};
     }
+  }
 
-    map.emplace(pointer, std::move(descriptor));
-
-    if (value.is_array()) {
-      fill_collection(map, accumulator, pointer, value);
-    }
+  for (const auto &pointer : collections) {
+    fill_collection(map, pointer, sourcemeta::core::get(instance, pointer));
   }
 
   return map;