jsonschema_frame.h

#ifndef SOURCEMETA_CORE_JSONSCHEMA_FRAME_H_
#define SOURCEMETA_CORE_JSONSCHEMA_FRAME_H_
 
#ifndef SOURCEMETA_CORE_JSONSCHEMA_EXPORT
#include <sourcemeta/core/jsonschema_export.h>
#endif
 
// NOLINTBEGIN(misc-include-cleaner)
#include <sourcemeta/core/jsonschema_error.h>
#include <sourcemeta/core/jsonschema_types.h>
// NOLINTEND(misc-include-cleaner)
 
#include <sourcemeta/core/json.h>
#include <sourcemeta/core/jsonpointer.h>
 
#include <concepts>   // std::invocable
#include <cstdint>    // std::uint8_t
#include <deque>      // std::deque
#include <functional> // std::reference_wrapper
#include <limits>     // std::numeric_limits
#include <map>        // std::map
#include <memory>     // std::unique_ptr
#include <optional>   // std::optional
#include <utility>    // std::pair
#include <vector>     // std::vector
 
namespace sourcemeta::core {

class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaFrame {
public:
  enum class Mode : std::uint8_t {
    Root,
    Locations,
    References,
    Pointers
  };

  enum class IdentifierMode : std::uint8_t {
    Additional,
    Fallback
  };
 
  ~SchemaFrame();
 
  // We rely on internal caches that would be dangling otherwise
  SchemaFrame(const SchemaFrame &) = delete;
  auto operator=(const SchemaFrame &) -> SchemaFrame & = delete;
  SchemaFrame(SchemaFrame &&) = delete;
  auto operator=(SchemaFrame &&) -> SchemaFrame & = delete;

  [[nodiscard]] auto mode() const noexcept -> Mode { return this->mode_; }

  struct Reference {
    std::string_view original;
    // TODO: This one is tricky to turn into a view, as there is no
    // location entry to point to if it is an external unresolved reference
    sourcemeta::core::JSON::String destination;
    std::string_view base;
    std::optional<std::string_view> fragment;
  };
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
// GCC believes that a member of an enum class (which is namespaced by
// definition), can shadow an alias defined even on a different namespace.
#pragma GCC diagnostic ignored "-Wshadow"
#endif
  enum class LocationType : std::uint8_t {
    Resource,
    Anchor,
    Pointer,
    Subschema
  };
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif

  struct Location {
    std::optional<sourcemeta::core::WeakPointer> parent;
    LocationType type;
    std::string_view base;
    sourcemeta::core::WeakPointer pointer;
    std::size_t relative_pointer;
    std::string_view dialect;
    SchemaBaseDialect base_dialect;
    bool property_name;
    bool orphan;
  };

  using Paths = std::vector<sourcemeta::core::WeakPointer>;

  [[nodiscard]] auto to_json(
      const SchemaResolver &resolver,
      const std::optional<sourcemeta::core::PointerPositionTracker> &tracker =
          std::nullopt) const -> sourcemeta::core::JSON;

  SchemaFrame(
      const Mode mode, const sourcemeta::core::JSON &root,
      const SchemaWalker &walker, const SchemaResolver &resolver,
      std::string_view default_dialect = "", std::string_view default_id = "",
      IdentifierMode identifier_mode = IdentifierMode::Additional,
      const Paths &paths = {sourcemeta::core::EMPTY_WEAK_POINTER},
      std::string_view default_base = "",
      std::uint64_t max_locations = std::numeric_limits<std::uint64_t>::max());

  [[nodiscard]] auto
  reference(const SchemaReferenceType type,
            const sourcemeta::core::WeakPointer &pointer) const
      -> std::optional<std::reference_wrapper<const Reference>>;

  [[nodiscard]] auto location(const SchemaReferenceType type,
                              const std::string_view uri) const
      -> std::optional<std::reference_wrapper<const Location>>;

  [[nodiscard]] auto location_count() const noexcept -> std::size_t;

  [[nodiscard]] auto reference_count() const noexcept -> std::size_t;

  [[nodiscard]] auto has_dynamic_references() const noexcept -> bool;

  [[nodiscard]] auto standalone() const noexcept -> bool;

  [[nodiscard]] auto root() const noexcept
      -> const sourcemeta::core::JSON::String &;

  [[nodiscard]] auto root_location() const
      -> std::optional<std::reference_wrapper<const Location>>;

  [[nodiscard]] auto metaschema(const SchemaResolver &resolver) const
      -> const sourcemeta::core::JSON &;

  [[nodiscard]] auto vocabularies(const Location &location,
                                  const SchemaResolver &resolver) const
      -> const SchemaVocabularies &;

  [[nodiscard]] auto
  uri(const Location &location,
      const sourcemeta::core::WeakPointer &relative_schema_location =
          sourcemeta::core::EMPTY_WEAK_POINTER) const
      -> sourcemeta::core::JSON::String;

  [[nodiscard]] auto
  traverse(const Location &location,
           const sourcemeta::core::WeakPointer &relative_schema_location) const
      -> const Location &;

  [[nodiscard]] auto traverse(const std::string_view uri) const
      -> std::optional<std::reference_wrapper<const Location>>;

  [[nodiscard]] auto
  traverse(const sourcemeta::core::WeakPointer &pointer) const
      -> std::optional<std::reference_wrapper<const Location>>;

  [[nodiscard]] auto traverse(const sourcemeta::core::WeakPointer &pointer,
                              const LocationType type) const
      -> std::optional<std::reference_wrapper<const Location>>;

  [[nodiscard]] auto uri(const sourcemeta::core::WeakPointer &pointer) const
      -> std::optional<
          std::reference_wrapper<const sourcemeta::core::JSON::String>>;

  [[nodiscard]] auto
  dereference(const Location &location,
              const sourcemeta::core::WeakPointer &relative_schema_location =
                  sourcemeta::core::EMPTY_WEAK_POINTER) const
      -> std::pair<SchemaReferenceType,
                   std::optional<std::reference_wrapper<const Location>>>;

  template <std::invocable<const Location &> F>
  auto for_each_subschema(const F &callback) const -> void {
    for (const auto &entry : this->locations_) {
      if (entry.second.type == LocationType::Resource ||
          entry.second.type == LocationType::Subschema) {
        callback(entry.second);
      }
    }
  }

  template <std::invocable<const Location &> F>
  auto for_each_subschema_under(const sourcemeta::core::WeakPointer &pointer,
                                const F &callback) const -> void {
    for (const auto &entry : this->locations_) {
      if ((entry.second.type == LocationType::Resource ||
           entry.second.type == LocationType::Subschema) &&
          entry.second.pointer.size() > pointer.size() &&
          entry.second.pointer.starts_with(pointer)) {
        callback(entry.second);
      }
    }
  }

  template <std::predicate<const Location &> F>
  [[nodiscard]] auto any_subschema(const F &predicate) const -> bool {
    for (const auto &entry : this->locations_) {
      if ((entry.second.type == LocationType::Resource ||
           entry.second.type == LocationType::Subschema) &&
          predicate(entry.second)) {
        return true;
      }
    }
 
    return false;
  }

  template <std::predicate<const Location &> F>
  [[nodiscard]] auto
  any_subschema_under(const sourcemeta::core::WeakPointer &pointer,
                      const F &predicate) const -> bool {
    for (const auto &entry : this->locations_) {
      if ((entry.second.type == LocationType::Resource ||
           entry.second.type == LocationType::Subschema) &&
          entry.second.pointer.size() > pointer.size() &&
          entry.second.pointer.starts_with(pointer) &&
          predicate(entry.second)) {
        return true;
      }
    }
 
    return false;
  }

  template <std::invocable<std::string_view, const Location &> F>
  auto for_each_anchor(const SchemaReferenceType type, const F &callback) const
      -> void {
    for (const auto &entry : this->locations_) {
      if (entry.first.first == type &&
          entry.second.type == LocationType::Anchor) {
        callback(entry.first.second, entry.second);
      }
    }
  }

  template <std::predicate<std::string_view, const Location &> F>
  [[nodiscard]] auto any_anchor(const SchemaReferenceType type,
                                const F &predicate) const -> bool {
    for (const auto &entry : this->locations_) {
      if (entry.first.first == type &&
          entry.second.type == LocationType::Anchor &&
          predicate(entry.first.second, entry.second)) {
        return true;
      }
    }
 
    return false;
  }

  template <std::invocable<std::string_view, const Location &> F>
  auto for_each_resource(const F &callback) const -> void {
    for (const auto &entry : this->locations_) {
      if (entry.second.type == LocationType::Resource) {
        callback(entry.first.second, entry.second);
      }
    }
  }

  template <
      std::invocable<SchemaReferenceType, std::string_view, const Location &> F>
  auto for_each_location(const F &callback) const -> void {
    for (const auto &entry : this->locations_) {
      callback(entry.first.first, entry.first.second, entry.second);
    }
  }

  template <
      std::predicate<SchemaReferenceType, std::string_view, const Location &> F>
  [[nodiscard]] auto any_location(const F &predicate) const -> bool {
    for (const auto &entry : this->locations_) {
      if (predicate(entry.first.first, entry.first.second, entry.second)) {
        return true;
      }
    }
 
    return false;
  }

  template <
      std::invocable<SchemaReferenceType, const sourcemeta::core::WeakPointer &,
                     const Reference &>
          F>
  auto for_each_reference(const F &callback) const -> void {
    for (const auto &entry : this->references_) {
      callback(entry.first.first, entry.first.second, entry.second);
    }
  }

  template <
      std::predicate<SchemaReferenceType, const sourcemeta::core::WeakPointer &,
                     const Reference &>
          F>
  [[nodiscard]] auto any_reference(const F &predicate) const -> bool {
    for (const auto &entry : this->references_) {
      if (predicate(entry.first.first, entry.first.second, entry.second)) {
        return true;
      }
    }
 
    return false;
  }

  template <
      std::invocable<SchemaReferenceType, const sourcemeta::core::WeakPointer &,
                     const Reference &>
          F>
  auto for_each_reference_from(const sourcemeta::core::WeakPointer &pointer,
                               const F &callback) const -> void {
    for (const auto &entry : this->references_) {
      if (entry.first.second.starts_with(pointer)) {
        callback(entry.first.first, entry.first.second, entry.second);
      }
    }
  }

  template <
      std::predicate<SchemaReferenceType, const sourcemeta::core::WeakPointer &,
                     const Reference &>
          F>
  [[nodiscard]] auto
  any_reference_from(const sourcemeta::core::WeakPointer &pointer,
                     const F &predicate) const -> bool {
    for (const auto &entry : this->references_) {
      if (entry.first.second.starts_with(pointer) &&
          predicate(entry.first.first, entry.first.second, entry.second)) {
        return true;
      }
    }
 
    return false;
  }

  template <
      std::invocable<SchemaReferenceType, const sourcemeta::core::WeakPointer &,
                     const Reference &>
          F>
  auto for_each_reference_into(const sourcemeta::core::WeakPointer &pointer,
                               const F &callback) const -> void {
    for (const auto &entry : this->references_) {
      const auto destination{this->traverse(entry.second.destination)};
      if (destination.has_value() &&
          destination.value().get().pointer.starts_with(pointer)) {
        callback(entry.first.first, entry.first.second, entry.second);
      }
    }
  }

  template <
      std::predicate<SchemaReferenceType, const sourcemeta::core::WeakPointer &,
                     const Reference &>
          F>
  [[nodiscard]] auto
  any_reference_into(const sourcemeta::core::WeakPointer &pointer,
                     const F &predicate) const -> bool {
    for (const auto &entry : this->references_) {
      const auto destination{this->traverse(entry.second.destination)};
      if (destination.has_value() &&
          destination.value().get().pointer.starts_with(pointer) &&
          predicate(entry.first.first, entry.first.second, entry.second)) {
        return true;
      }
    }
 
    return false;
  }

  template <std::invocable<std::string_view> F>
  auto for_each_resource_uri(const F &callback) const -> void {
    for (const auto &[key, location] : this->locations_) {
      if (location.type == LocationType::Resource) {
        callback(key.second);
      }
    }
  }

  template <
      std::invocable<const sourcemeta::core::WeakPointer &, const Reference &>
          F>
  auto for_each_unresolved_reference(const F &callback) const -> void {
    for (const auto &[key, reference] : this->references_) {
      if (!this->traverse(reference.destination).has_value()) {
        callback(key.second, reference);
      }
    }
  }

  [[nodiscard]] auto
  has_references_to(const sourcemeta::core::WeakPointer &pointer) const -> bool;

  [[nodiscard]] auto
  has_references_through(const sourcemeta::core::WeakPointer &pointer) const
      -> bool;
  [[nodiscard]] auto
  has_references_through(const sourcemeta::core::WeakPointer &pointer,
                         const sourcemeta::core::WeakPointer::Token &tail) const
      -> bool;

  [[nodiscard]] auto relative_instance_location(const Location &location) const
      -> sourcemeta::core::WeakPointer;

  [[nodiscard]] auto is_reachable(const Location &base,
                                  const Location &location,
                                  const SchemaWalker &walker,
                                  const SchemaResolver &resolver) const -> bool;
 
private:
  using References =
      std::map<std::pair<SchemaReferenceType, sourcemeta::core::WeakPointer>,
               Reference>;
 
  using Locations =
      // While it might seem weird that we namespace the location URIs with a
      // reference type, it is essential for distinguishing schema resource URIs
      // from `$recursiveRef: true` on another place of the schema schema
      // resource, as otherwise they would both have the exact same URI, but
      // point to different places.
      std::map<std::pair<SchemaReferenceType, sourcemeta::core::JSON::String>,
               Location>;
 
  Mode mode_;
// Exporting symbols that depends on the standard C++ library is considered
// safe.
// https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4275?view=msvc-170&redirectedfrom=MSDN
#if defined(_MSC_VER)
#pragma warning(disable : 4251 4275)
#endif
  sourcemeta::core::JSON::String root_;
  // A reference may target a place that no schema location covers, in which
  // case framing materialises one for it. Unlike every other location, the
  // tokens of those pointers are not borrowed from the analysed document, so
  // they have to be declared here to outlive the locations that borrow them
  std::deque<sourcemeta::core::Pointer> reference_pointers_;
  Locations locations_;
  References references_;
  // What the frame derives rather than is, kept out of line so that this
  // declaration stays down to the schema it framed
  struct Cache;
  std::unique_ptr<Cache> cache_;
#if defined(_MSC_VER)
#pragma warning(default : 4251 4275)
#endif
};
 
} // namespace sourcemeta::core
 
#endif