Get rid of frame locations() / references() leaky getters

benchmark/frame.cc

@@ -104,24 +104,26 @@ static void Schema_Frame_KrakenD_Reachable(benchmark::State &state) {
                   sourcemeta::blaze::schema_resolver);
     state.ResumeTiming();
 
-    for (const auto &entry : frame->locations()) {
-      if (entry.second.type ==
-          sourcemeta::blaze::SchemaFrame::LocationType::Pointer) {
-        continue;
-      }
-
-      for (const auto &subentry : frame->locations()) {
-        if (subentry.second.type ==
-                sourcemeta::blaze::SchemaFrame::LocationType::Resource ||
-            subentry.second.type ==
-                sourcemeta::blaze::SchemaFrame::LocationType::Subschema) {
-          auto result{frame->is_reachable(subentry.second, entry.second,
-                                          sourcemeta::blaze::schema_walker,
-                                          sourcemeta::blaze::schema_resolver)};
-          benchmark::DoNotOptimize(result);
-        }
-      }
-    }
+    frame->for_each_location(
+        [&frame](
+            const sourcemeta::blaze::SchemaReferenceType,
+            const std::string_view,
+            const sourcemeta::blaze::SchemaFrame::Location &entry) -> void {
+          if (entry.type ==
+              sourcemeta::blaze::SchemaFrame::LocationType::Pointer) {
+            return;
+          }
+
+          frame->for_each_subschema(
+              [&frame,
+               &entry](const sourcemeta::blaze::SchemaFrame::Location &subentry)
+                  -> void {
+                auto result{frame->is_reachable(
+                    subentry, entry, sourcemeta::blaze::schema_walker,
+                    sourcemeta::blaze::schema_resolver)};
+                benchmark::DoNotOptimize(result);
+              });
+        });
   }
 }
 

src/alterschema/common/orphan_definitions.h

@@ -69,19 +69,13 @@ class OrphanDefinitions final : public SchemaTransformRule {
   static auto
   subtree_has_dynamic_anchor(const sourcemeta::blaze::SchemaFrame &frame,
                              const WeakPointer &entry_pointer) -> bool {
-    for (const auto &[key, location] : frame.locations()) {
-      if (key.first != sourcemeta::blaze::SchemaReferenceType::Dynamic) {
-        continue;
-      }
-      if (location.type !=
-          sourcemeta::blaze::SchemaFrame::LocationType::Anchor) {
-        continue;
-      }
-      if (location.pointer.starts_with(entry_pointer)) {
-        return true;
-      }
-    }
-    return false;
+    return frame.any_anchor(
+        sourcemeta::blaze::SchemaReferenceType::Dynamic,
+        [&entry_pointer](
+            const std::string_view,
+            const sourcemeta::blaze::SchemaFrame::Location &location) -> bool {
+          return location.pointer.starts_with(entry_pointer);
+        });
   }
 
   static auto has_reachable_reference_through(
@@ -90,31 +84,22 @@ class OrphanDefinitions final : public SchemaTransformRule {
       const sourcemeta::blaze::SchemaWalker &walker,
       const sourcemeta::blaze::SchemaResolver &resolver,
       const WeakPointer &pointer) -> bool {
-    for (const auto &reference : frame.references()) {
-      const auto destination{frame.traverse(reference.second.destination)};
-      if (!destination.has_value()) {
-        continue;
-      }
-
-      if (!destination->get().pointer.starts_with(pointer)) {
-        continue;
-      }
-
-      const auto &source_pointer{reference.first.second};
-      if (source_pointer.empty()) {
-        return true;
-      }
-
-      const auto source_location{frame.traverse(
-          source_pointer.initial(),
-          sourcemeta::blaze::SchemaFrame::LocationType::Subschema)};
-      if (source_location.has_value() &&
-          frame.is_reachable(base, source_location->get(), walker, resolver)) {
-        return true;
-      }
-    }
+    return frame.any_reference_into(
+        pointer,
+        [&](const sourcemeta::blaze::SchemaReferenceType,
+            const sourcemeta::core::WeakPointer &source_pointer,
+            const sourcemeta::blaze::SchemaFrame::Reference &) -> bool {
+          if (source_pointer.empty()) {
+            return true;
+          }
 
-    return false;
+          const auto source_location{frame.traverse(
+              source_pointer.initial(),
+              sourcemeta::blaze::SchemaFrame::LocationType::Subschema)};
+          return source_location.has_value() &&
+                 frame.is_reachable(base, source_location->get(), walker,
+                                    resolver);
+        });
   }
 
   static auto

src/alterschema/linter/invalid_external_ref.h

@@ -99,7 +99,7 @@ class InvalidExternalRef final : public SchemaTransformRule {
       frame_cache_;
 
   [[nodiscard]] auto
-  is_fragment_invalid(const SchemaFrame::ReferencesEntry &reference_entry,
+  is_fragment_invalid(const SchemaFrame::Reference &reference_entry,
                       const std::optional<JSON> &remote,
                       const JSON::String &base_key, const SchemaWalker &walker,
                       const SchemaResolver &resolver,