Merge branch 'refactor/validation-visitor/document-as-argument' into feat/extension-model

# Conflicts:
#	include/jvalidate/validation_result.h

include/jvalidate/forward.h

@@ -171,7 +171,7 @@ concept RegexEngine = std::constructible_from<std::string> && requires(R const r
 namespace jvalidate {
 template <Adapter A> class ConstraintFactory;
 template <Adapter A> class DocumentCache;
-template <Adapter A, RegexEngine RE> class ValidationVisitor;
+template <RegexEngine RE> class ValidationVisitor;
 
 template <RegexEngine RE> class ValidatorT;
 class Validator;

include/jvalidate/validation_result.h

@@ -13,7 +13,7 @@ namespace jvalidate {
 class ValidationResult {
 public:
   // Only allow ValidationVisitor to construct the elements of a validation result
-  template <Adapter, RegexEngine> friend class ValidationVisitor;
+  template <RegexEngine> friend class ValidationVisitor;
 
   using DocPointer = detail::Pointer;
   using SchemaPointer = detail::Pointer;

include/jvalidate/validation_visitor.h

@@ -33,8 +33,7 @@
     }                                                                                              \
   } while (false)
 
-#define NOOP_UNLESS_TYPE(etype)                                                                    \
-  RETURN_UNLESS(adapter::Type::etype == document_.type(), Status::Noop)
+#define NOOP_UNLESS_TYPE(etype) RETURN_UNLESS(adapter::Type::etype == document.type(), Status::Noop)
 
 #define BREAK_EARLY_IF_NO_RESULT_TREE()                                                            \
   do {                                                                                             \
@@ -44,13 +43,12 @@
   } while (false)
 
 namespace jvalidate {
-template <Adapter A, RegexEngine RE> class ValidationVisitor {
+template <RegexEngine RE> class ValidationVisitor {
 private:
   using VisitedAnnotation = std::tuple<std::unordered_set<size_t>, std::unordered_set<std::string>>;
   JVALIDATE_TRIBOOL_TYPE(StoreResults, ForValid, ForInvalid, ForAnything);
 
 private:
-  A document_;
   detail::Pointer where_;
   detail::Pointer schema_path_;
 
@@ -68,7 +66,6 @@ public:
   /**
    * @brief Construct a new ValidationVisitor
    *
-   * @param json The JSON document instance being validated
    * @param schema The parsed JSON Schema
    * @param cfg General configuration settings for how the run is executed
    * @param regex_cache A cache of string regular expressions to compiled
@@ -76,12 +73,12 @@ public:
    * @param[optional] result A cache of result/annotation info for the user to
    * receive a detailed summary of why a document is supported/unsupported.
    */
-  ValidationVisitor(A const & json, schema::Node const & schema, ValidationConfig const & cfg,
+  ValidationVisitor(schema::Node const & schema, ValidationConfig const & cfg,
                     std::unordered_map<std::string, RE> & regex_cache, ValidationResult * result)
-      : document_(json), schema_(&schema), result_(result), cfg_(cfg), regex_cache_(regex_cache) {}
+      : schema_(&schema), result_(result), cfg_(cfg), regex_cache_(regex_cache) {}
 
-  Status visit(constraint::TypeConstraint const & cons) const {
-    adapter::Type const type = document_.type();
+  Status visit(constraint::TypeConstraint const & cons, Adapter auto const & document) const {
+    adapter::Type const type = document.type();
 
     for (adapter::Type const accept : cons.types) {
       if (type == accept) {
@@ -91,20 +88,20 @@ public:
         return result(Status::Accept, type, " is in types [", cons.types, "]");
       }
       if (accept == adapter::Type::Integer && type == adapter::Type::Number &&
-          detail::is_json_integer(document_.as_number())) {
+          detail::is_json_integer(document.as_number())) {
         return result(Status::Accept, type, " is in types [", cons.types, "]");
       }
     }
     return result(Status::Reject, type, " is not in types [", cons.types, "]");
   }
 
-  Status visit(constraint::ExtensionConstraint const & cons) const {
-    // return cons.validate(document_, where_, result_);
+  Status visit(constraint::ExtensionConstraint const & cons, Adapter auto const & document) const {
+    // return cons.validate(document, where_, result_);
   }
 
-  Status visit(constraint::EnumConstraint const & cons) const {
-    auto is_equal = [this](auto const & frozen) {
-      return document_.equals(frozen, cfg_.strict_equality);
+  Status visit(constraint::EnumConstraint const & cons, Adapter auto const & document) const {
+    auto is_equal = [this, &document](auto const & frozen) {
+      return document.equals(frozen, cfg_.strict_equality);
     };
     for (auto const & [index, option] : detail::enumerate(cons.enumeration)) {
       if (option->apply(is_equal)) {
@@ -114,12 +111,12 @@ public:
     return Status::Reject;
   }
 
-  Status visit(constraint::AllOfConstraint const & cons) const {
+  Status visit(constraint::AllOfConstraint const & cons, Adapter auto const & document) const {
     Status rval = Status::Accept;
 
     std::set<size_t> unmatched;
     for (auto const & [index, subschema] : detail::enumerate(cons.children)) {
-      if (auto stat = validate_subschema(subschema, index); stat == Status::Reject) {
+      if (auto stat = validate_subschema(subschema, document, index); stat == Status::Reject) {
         rval = Status::Reject;
         unmatched.insert(index);
       }
@@ -132,10 +129,10 @@ public:
     return result(rval, "validates all subschemas");
   }
 
-  Status visit(constraint::AnyOfConstraint const & cons) const {
+  Status visit(constraint::AnyOfConstraint const & cons, Adapter auto const & document) const {
     std::optional<size_t> first_validated;
     for (auto const & [index, subschema] : detail::enumerate(cons.children)) {
-      if (validate_subschema(subschema, index)) {
+      if (validate_subschema(subschema, document, index)) {
         first_validated = index;
       }
       if (not visited_ && first_validated.has_value()) {
@@ -149,12 +146,12 @@ public:
     return result(Status::Reject, "validates none of the subschemas");
   }
 
-  Status visit(constraint::OneOfConstraint const & cons) const {
+  Status visit(constraint::OneOfConstraint const & cons, Adapter auto const & document) const {
     std::set<size_t> matches;
 
     for (auto const & [index, subschema] : detail::enumerate(cons.children)) {
       scoped_state(tracking_, StoreResults::ForAnything);
-      if (validate_subschema(subschema, index)) {
+      if (validate_subschema(subschema, document, index)) {
         matches.insert(index);
       }
     }
@@ -165,37 +162,38 @@ public:
     return result(Status::Reject, "validates multiple subschemas ", matches);
   }
 
-  Status visit(constraint::NotConstraint const & cons) const {
+  Status visit(constraint::NotConstraint const & cons, Adapter auto const & document) const {
     scoped_state(visited_, nullptr);
     scoped_state(tracking_, !tracking_);
-    bool const rejected = validate_subschema(cons.child) == Status::Reject;
+    bool const rejected = validate_subschema(cons.child, document) == Status::Reject;
 
     return rejected;
   }
 
-  Status visit(constraint::ConditionalConstraint const & cons) const {
-    Status const if_true = [this, &cons]() {
+  Status visit(constraint::ConditionalConstraint const & cons,
+               Adapter auto const & document) const {
+    Status const if_true = [this, &cons, &document]() {
       scoped_state(tracking_, StoreResults::ForAnything);
-      return validate_subschema(cons.if_constraint);
+      return validate_subschema(cons.if_constraint, document);
     }();
 
     annotate(if_true ? "valid" : "invalid");
     if (if_true) {
-      return validate_subschema(cons.then_constraint, detail::parent, "then");
+      return validate_subschema(cons.then_constraint, document, detail::parent, "then");
     }
-    return validate_subschema(cons.else_constraint, detail::parent, "else");
+    return validate_subschema(cons.else_constraint, document, detail::parent, "else");
   }
 
-  Status visit(constraint::MaximumConstraint const & cons) const {
-    switch (document_.type()) {
+  Status visit(constraint::MaximumConstraint const & cons, Adapter auto const & document) const {
+    switch (document.type()) {
     case adapter::Type::Integer:
-      if (int64_t value = document_.as_integer(); not cons(value)) {
+      if (int64_t value = document.as_integer(); not cons(value)) {
         return result(Status::Reject, value, cons.exclusive ? " >= " : " > ", cons.value);
       } else {
         return result(Status::Accept, value, cons.exclusive ? " < " : " <= ", cons.value);
       }
     case adapter::Type::Number:
-      if (double value = document_.as_number(); not cons(value)) {
+      if (double value = document.as_number(); not cons(value)) {
         return result(Status::Reject, value, cons.exclusive ? " >= " : " > ", cons.value);
       } else {
         return result(Status::Accept, value, cons.exclusive ? " < " : " <= ", cons.value);
@@ -205,16 +203,16 @@ public:
     }
   }
 
-  Status visit(constraint::MinimumConstraint const & cons) const {
-    switch (document_.type()) {
+  Status visit(constraint::MinimumConstraint const & cons, Adapter auto const & document) const {
+    switch (document.type()) {
     case adapter::Type::Integer:
-      if (int64_t value = document_.as_integer(); not cons(value)) {
+      if (int64_t value = document.as_integer(); not cons(value)) {
         return result(Status::Reject, value, cons.exclusive ? " <= " : " < ", cons.value);
       } else {
         return result(Status::Accept, value, cons.exclusive ? " > " : " >= ", cons.value);
       }
     case adapter::Type::Number:
-      if (double value = document_.as_number(); not cons(value)) {
+      if (double value = document.as_number(); not cons(value)) {
         return result(Status::Reject, value, cons.exclusive ? " <= " : " < ", cons.value);
       } else {
         return result(Status::Accept, value, cons.exclusive ? " > " : " >= ", cons.value);
@@ -224,20 +222,20 @@ public:
     }
   }
 
-  Status visit(constraint::MultipleOfConstraint const & cons) const {
-    adapter::Type const type = document_.type();
+  Status visit(constraint::MultipleOfConstraint const & cons, Adapter auto const & document) const {
+    adapter::Type const type = document.type();
     RETURN_UNLESS(type == adapter::Type::Number || type == adapter::Type::Integer, Status::Noop);
 
-    if (double value = document_.as_number(); not cons(value)) {
+    if (double value = document.as_number(); not cons(value)) {
       return result(Status::Reject, value, " is not a multiple of ", cons.value);
     } else {
       return result(Status::Accept, value, " is a multiple of ", cons.value);
     }
   }
 
-  Status visit(constraint::MaxLengthConstraint const & cons) const {
+  Status visit(constraint::MaxLengthConstraint const & cons, Adapter auto const & document) const {
     NOOP_UNLESS_TYPE(String);
-    std::string const str = document_.as_string();
+    std::string const str = document.as_string();
     if (int64_t len = detail::length(str); len > cons.value) {
       return result(Status::Reject, "string of length ", len, " is >", cons.value);
     } else {
@@ -245,9 +243,9 @@ public:
     }
   }
 
-  Status visit(constraint::MinLengthConstraint const & cons) const {
+  Status visit(constraint::MinLengthConstraint const & cons, Adapter auto const & document) const {
     NOOP_UNLESS_TYPE(String);
-    std::string const str = document_.as_string();
+    std::string const str = document.as_string();
     if (int64_t len = detail::length(str); len < cons.value) {
       return result(Status::Reject, "string of length ", len, " is <", cons.value);
     } else {
@@ -255,18 +253,18 @@ public:
     }
   }
 
-  Status visit(constraint::PatternConstraint const & cons) const {
+  Status visit(constraint::PatternConstraint const & cons, Adapter auto const & document) const {
     NOOP_UNLESS_TYPE(String);
 
     RE const & regex = regex_cache_.try_emplace(cons.regex, cons.regex).first->second;
-    std::string const str = document_.as_string();
+    std::string const str = document.as_string();
     if (regex.search(str)) {
       return result(Status::Accept, "string matches pattern /", cons.regex, "/");
     }
     return result(Status::Reject, "string does not match pattern /", cons.regex, "/");
   }
 
-  Status visit(constraint::FormatConstraint const & cons) const {
+  Status visit(constraint::FormatConstraint const & cons, Adapter auto const & document) const {
     // https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#name-defined-formats
     NOOP_UNLESS_TYPE(String);
 
@@ -278,10 +276,11 @@ public:
     return result(Status::Reject, " is unimplemented");
   }
 
-  Status visit(constraint::AdditionalItemsConstraint const & cons) const {
+  Status visit(constraint::AdditionalItemsConstraint const & cons,
+               Adapter auto const & document) const {
     NOOP_UNLESS_TYPE(Array);
 
-    auto array = document_.as_array();
+    auto array = document.as_array();
 
     Status rval = Status::Accept;
     std::vector<size_t> items;
@@ -294,10 +293,10 @@ public:
     return rval;
   }
 
-  Status visit(constraint::ContainsConstraint const & cons) const {
+  Status visit(constraint::ContainsConstraint const & cons, Adapter auto const & document) const {
     NOOP_UNLESS_TYPE(Array);
 
-    auto array = document_.as_array();
+    auto array = document.as_array();
     size_t const minimum = cons.minimum.value_or(1);
     size_t const maximum = cons.maximum.value_or(array.size());
     size_t matches = 0;
@@ -316,31 +315,31 @@ public:
     return result(Status::Accept, "array contains ", matches, " matching items");
   }
 
-  Status visit(constraint::MaxItemsConstraint const & cons) const {
+  Status visit(constraint::MaxItemsConstraint const & cons, Adapter auto const & document) const {
     NOOP_UNLESS_TYPE(Array);
-    if (size_t size = document_.array_size(); size > cons.value) {
+    if (size_t size = document.array_size(); size > cons.value) {
       return result(Status::Reject, "array of size ", size, " is >", cons.value);
     } else {
       return result(Status::Accept, "array of size ", size, " is <=", cons.value);
     }
   }
 
-  Status visit(constraint::MinItemsConstraint const & cons) const {
+  Status visit(constraint::MinItemsConstraint const & cons, Adapter auto const & document) const {
     NOOP_UNLESS_TYPE(Array);
-    if (size_t size = document_.array_size(); size < cons.value) {
+    if (size_t size = document.array_size(); size < cons.value) {
       return result(Status::Reject, "array of size ", size, " is <", cons.value);
     } else {
       return result(Status::Accept, "array of size ", size, " is >=", cons.value);
     }
   }
 
-  Status visit(constraint::TupleConstraint const & cons) const {
+  Status visit(constraint::TupleConstraint const & cons, Adapter auto const & document) const {
     NOOP_UNLESS_TYPE(Array);
 
     Status rval = Status::Accept;
 
     std::vector<size_t> items;
-    for (auto const & [index, item] : detail::enumerate(document_.as_array())) {
+    for (auto const & [index, item] : detail::enumerate(document.as_array())) {
       if (index >= cons.items.size()) {
         break;
       }
@@ -352,18 +351,19 @@ public:
     return rval;
   }
 
-  Status visit(constraint::UniqueItemsConstraint const & cons) const {
+  template <Adapter A>
+  Status visit(constraint::UniqueItemsConstraint const & cons, A const & document) const {
     NOOP_UNLESS_TYPE(Array);
 
     if constexpr (std::totally_ordered<A>) {
       std::map<A, size_t> cache;
-      for (auto const & [index, elem] : detail::enumerate(document_.as_array())) {
+      for (auto const & [index, elem] : detail::enumerate(document.as_array())) {
         if (auto [it, created] = cache.emplace(elem, index); not created) {
           return result(Status::Reject, "items ", it->second, " and ", index, " are equal");
         }
       }
     } else {
-      auto array = document_.as_array();
+      auto array = document.as_array();
       for (size_t i = 0; i < array.size(); ++i) {
         for (size_t j = i + 1; j < array.size(); ++j) {
           if (array[i].equals(array[j], true)) {
@@ -376,7 +376,8 @@ public:
     return result(Status::Accept, "all array items are unique");
   }
 
-  Status visit(constraint::AdditionalPropertiesConstraint const & cons) const {
+  Status visit(constraint::AdditionalPropertiesConstraint const & cons,
+               Adapter auto const & document) const {
     NOOP_UNLESS_TYPE(Object);
 
     auto matches_any_pattern = [this, &cons](std::string const & key) {
@@ -391,7 +392,7 @@ public:
 
     Status rval = Status::Accept;
     std::vector<std::string> properties;
-    for (auto const & [key, elem] : document_.as_object()) {
+    for (auto const & [key, elem] : document.as_object()) {
       if (not cons.properties.contains(key) && not matches_any_pattern(key)) {
         VALIDATE_SUBSCHEMA_AND_MARK_LOCAL_VISIT(cons.subschema, elem, key, properties);
       }
@@ -402,17 +403,18 @@ public:
     return rval;
   }
 
-  Status visit(constraint::DependenciesConstraint const & cons) const {
+  Status visit(constraint::DependenciesConstraint const & cons,
+               Adapter auto const & document) const {
     NOOP_UNLESS_TYPE(Object);
 
-    auto object = document_.as_object();
+    auto object = document.as_object();
     Status rval = Status::Accept;
     for (auto const & [key, subschema] : cons.subschemas) {
       if (not object.contains(key)) {
         continue;
       }
 
-      rval &= validate_subschema(subschema, key);
+      rval &= validate_subschema(subschema, document, key);
       BREAK_EARLY_IF_NO_RESULT_TREE();
     }
 
@@ -432,32 +434,35 @@ public:
     return rval;
   }
 
-  Status visit(constraint::MaxPropertiesConstraint const & cons) const {
+  Status visit(constraint::MaxPropertiesConstraint const & cons,
+               Adapter auto const & document) const {
     NOOP_UNLESS_TYPE(Object);
-    if (size_t size = document_.object_size(); size > cons.value) {
+    if (size_t size = document.object_size(); size > cons.value) {
       return result(Status::Reject, "object of size ", size, " is >", cons.value);
     } else {
       return result(Status::Accept, "object of size ", size, " is <=", cons.value);
     }
   }
 
-  Status visit(constraint::MinPropertiesConstraint const & cons) const {
+  Status visit(constraint::MinPropertiesConstraint const & cons,
+               Adapter auto const & document) const {
     NOOP_UNLESS_TYPE(Object);
-    if (size_t size = document_.object_size(); size < cons.value) {
+    if (size_t size = document.object_size(); size < cons.value) {
       return result(Status::Reject, "object of size ", size, " is <", cons.value);
     } else {
       return result(Status::Accept, "object of size ", size, " is >=", cons.value);
     }
   }
 
-  Status visit(constraint::PatternPropertiesConstraint const & cons) const {
+  Status visit(constraint::PatternPropertiesConstraint const & cons,
+               Adapter auto const & document) const {
     NOOP_UNLESS_TYPE(Object);
 
     std::vector<std::string> properties;
     Status rval = Status::Accept;
     for (auto const & [pattern, subschema] : cons.properties) {
       RE const & regex = regex_cache_.try_emplace(pattern, pattern).first->second;
-      for (auto const & [key, elem] : document_.as_object()) {
+      for (auto const & [key, elem] : document.as_object()) {
         if (not regex.search(key)) {
           continue;
         }
@@ -470,11 +475,12 @@ public:
     return rval;
   }
 
-  Status visit(constraint::PropertiesConstraint const & cons) const {
+  template <Adapter A>
+  Status visit(constraint::PropertiesConstraint const & cons, A const & document) const {
     NOOP_UNLESS_TYPE(Object);
 
     Status rval = Status::Accept;
-    auto object = document_.as_object();
+    auto object = document.as_object();
 
     if constexpr (MutableAdapter<A>) {
       for (auto const & [key, subschema] : cons.properties) {
@@ -497,11 +503,12 @@ public:
     return rval;
   }
 
-  Status visit(constraint::PropertyNamesConstraint const & cons) const {
+  template <Adapter A>
+  Status visit(constraint::PropertyNamesConstraint const & cons, A const & document) const {
     NOOP_UNLESS_TYPE(Object);
 
     Status rval = Status::Accept;
-    for (auto const & [key, _] : document_.as_object()) {
+    for (auto const & [key, _] : document.as_object()) {
       // TODO(samjaffe): Should we prefer a std::string adapter like valijson?
       typename A::value_type key_json{key};
       rval &= validate_subschema_on(cons.key_schema, A(key_json), std::string("$$key"));
@@ -509,11 +516,11 @@ public:
     return rval;
   }
 
-  Status visit(constraint::RequiredConstraint const & cons) const {
+  Status visit(constraint::RequiredConstraint const & cons, Adapter auto const & document) const {
     NOOP_UNLESS_TYPE(Object);
 
     auto required = cons.properties;
-    for (auto const & [key, _] : document_.as_object()) {
+    for (auto const & [key, _] : document.as_object()) {
       required.erase(key);
     }
 
@@ -524,7 +531,8 @@ public:
     return result(Status::Reject, "missing required properties ", required);
   }
 
-  Status visit(constraint::UnevaluatedItemsConstraint const & cons) const {
+  Status visit(constraint::UnevaluatedItemsConstraint const & cons,
+               Adapter auto const & document) const {
     NOOP_UNLESS_TYPE(Array);
     if (not visited_) {
       return Status::Reject;
@@ -532,7 +540,7 @@ public:
 
     Status rval = Status::Accept;
     std::vector<size_t> items;
-    for (auto const & [index, item] : detail::enumerate(document_.as_array())) {
+    for (auto const & [index, item] : detail::enumerate(document.as_array())) {
       if (not VISITED(size_t).contains(index)) {
         VALIDATE_SUBSCHEMA_AND_MARK_LOCAL_VISIT(cons.subschema, item, index, items);
       }
@@ -543,7 +551,8 @@ public:
     return rval;
   }
 
-  Status visit(constraint::UnevaluatedPropertiesConstraint const & cons) const {
+  Status visit(constraint::UnevaluatedPropertiesConstraint const & cons,
+               Adapter auto const & document) const {
     NOOP_UNLESS_TYPE(Object);
     if (not visited_) {
       return Status::Reject;
@@ -551,7 +560,7 @@ public:
 
     Status rval = Status::Accept;
     std::vector<std::string> properties;
-    for (auto const & [key, elem] : document_.as_object()) {
+    for (auto const & [key, elem] : document.as_object()) {
       if (not VISITED(std::string).contains(key)) {
         VALIDATE_SUBSCHEMA_AND_MARK_LOCAL_VISIT(cons.subschema, elem, key, properties);
       }
@@ -566,7 +575,7 @@ public:
    * @brief The main entry point into the validator. Validates the provided
    * document according to the schema.
    */
-  Status validate() {
+  Status validate(Adapter auto const & document) {
     // Step 1) Check if this is an always-false schema. Sometimes, this will
     // have a custom message.
     if (std::optional<std::string> const & reject = schema_->rejects_all()) {
@@ -600,14 +609,14 @@ public:
     // constraints. This is enforced in the parsing of the schema, rather than
     // during validation {@see jvalidate::schema::Node::construct}.
     if (std::optional<schema::Node const *> ref = schema_->reference_schema()) {
-      rval = validate_subschema(*ref, "$ref");
+      rval = validate_subschema(*ref, document, "$ref");
     }
 
     detail::Pointer const current_schema = schema_path_;
     for (auto const & [key, p_constraint] : schema_->constraints()) {
       BREAK_EARLY_IF_NO_RESULT_TREE();
       schema_path_ = current_schema / key;
-      rval &= std::visit([this](auto & c) { return visit(c); }, *p_constraint);
+      rval &= std::visit([this, &document](auto & c) { return visit(c, document); }, *p_constraint);
     }
 
     // Post Constraints represent the unevaluatedItems and unevaluatedProperties
@@ -615,7 +624,7 @@ public:
     for (auto const & [key, p_constraint] : schema_->post_constraints()) {
       BREAK_EARLY_IF_NO_RESULT_TREE();
       schema_path_ = current_schema / key;
-      rval &= std::visit([this](auto & c) { return visit(c); }, *p_constraint);
+      rval &= std::visit([this, &document](auto & c) { return visit(c, document); }, *p_constraint);
     }
 
     (result_ ? result_->valid(where_, current_schema, static_cast<bool>(rval)) : void());
@@ -689,11 +698,13 @@ private:
    * subschema.
    */
   template <typename... K>
-  Status validate_subschema(constraint::SubConstraint const & subschema, K const &... keys) const {
+  Status validate_subschema(constraint::SubConstraint const & subschema,
+                            Adapter auto const & document, K const &... keys) const {
     if (schema::Node const * const * ppschema = std::get_if<0>(&subschema)) {
-      return validate_subschema(*ppschema, keys...);
+      return validate_subschema(*ppschema, document, keys...);
     } else {
-      return std::visit([this](auto & c) { return visit(c); }, *std::get<1>(subschema));
+      return std::visit([this, &document](auto & c) { return visit(c, document); },
+                        *std::get<1>(subschema));
     }
   }
 
@@ -709,7 +720,8 @@ private:
    * subschema.
    */
   template <typename... K>
-  Status validate_subschema(schema::Node const * subschema, K const &... keys) const {
+  Status validate_subschema(schema::Node const * subschema, Adapter auto const & document,
+                            K const &... keys) const {
     VisitedAnnotation annotate;
 
     ValidationVisitor next = *this;
@@ -717,7 +729,7 @@ private:
     std::tie(next.schema_, next.visited_) =
         std::forward_as_tuple(subschema, visited_ ? &annotate : nullptr);
 
-    Status rval = next.validate();
+    Status rval = next.validate(document);
 
     if (rval == Status::Accept and visited_) {
       std::get<0>(*visited_).merge(std::get<0>(annotate));
@@ -738,16 +750,16 @@ private:
    * subschema.
    */
   template <typename K>
-  Status validate_subschema_on(schema::Node const * subschema, A const & document,
+  Status validate_subschema_on(schema::Node const * subschema, Adapter auto const & document,
                                K const & key) const {
     ValidationResult result;
 
     ValidationVisitor next = *this;
     next.where_ /= key;
-    std::tie(next.document_, next.schema_, next.result_, next.visited_) =
-        std::forward_as_tuple(document, subschema, result_ ? &result : nullptr, nullptr);
+    std::tie(next.schema_, next.result_, next.visited_) =
+        std::forward_as_tuple(subschema, result_ ? &result : nullptr, nullptr);
 
-    auto status = next.validate();
+    auto status = next.validate(document);
     if (status == Status::Accept and visited_) {
       VISITED(K).insert(key);
     }

include/jvalidate/validator.h

@@ -76,7 +76,7 @@ public:
     EXPECT_M(not cfg_.construct_default_values,
              "Cannot perform mutations on an immutable JSON Adapter");
     return static_cast<bool>(
-        ValidationVisitor<A, RE>(json, schema_, cfg_, regex_cache_, result).validate());
+        ValidationVisitor<RE>(schema_, cfg_, regex_cache_, result).validate(json));
   }
 
   /**
@@ -95,7 +95,7 @@ public:
    */
   template <MutableAdapter A> bool validate(A const & json, ValidationResult * result = nullptr) {
     return static_cast<bool>(
-        ValidationVisitor<A, RE>(json, schema_, cfg_, regex_cache_, result).validate());
+        ValidationVisitor<RE>(schema_, cfg_, regex_cache_, result).validate(json));
   }
 
   /**