refactor: create a separate constraint to log for "const"

include/jvalidate/adapter.h

@@ -407,6 +407,10 @@ private:
 }
 
 namespace std {
+inline ostream & operator<<(ostream & os, unique_ptr<jvalidate::adapter::Const const> const & ptr) {
+  return os << *ptr;
+}
+
 inline ostream & operator<<(ostream & os,
                             vector<unique_ptr<jvalidate::adapter::Const const>> const & items) {
   std::string_view div;

include/jvalidate/constraint.h

@@ -454,8 +454,7 @@ public:
    * @returns A constraint that checks equality against a single value.
    */
   static auto isConstant(detail::ParserContext<A> const & context) {
-    constraint::EnumConstraint rval;
-    rval.enumeration.push_back(context.schema.freeze());
+    constraint::ConstConstraint rval{.value = context.schema.freeze()};
     return ptr(rval);
   }
 

include/jvalidate/constraint/general_constraint.h

@@ -16,6 +16,10 @@ struct AnyOfConstraint {
   std::vector<SubConstraint> children;
 };
 
+struct ConstConstraint {
+  std::unique_ptr<adapter::Const const> value;
+};
+
 struct EnumConstraint {
   std::vector<std::unique_ptr<adapter::Const const>> enumeration;
 };

include/jvalidate/forward.h

@@ -43,6 +43,7 @@ namespace jvalidate::constraint {
 #define CONSTRAINT_IMPLEMENTATION_LIST(X)                                                          \
   /* General Constraints - See jvalidate/constraint/general_constraint.h */                        \
   X(TypeConstraint)                                                                                \
+  X(ConstConstraint)                                                                               \
   X(EnumConstraint)                                                                                \
   X(AllOfConstraint)                                                                               \
   X(AnyOfConstraint)                                                                               \

include/jvalidate/validation_visitor.h

@@ -108,6 +108,16 @@ public:
     return result(Status::Reject, type, " is not in types [", cons.types, "]");
   }
 
+  Status visit(constraint::ConstConstraint const & cons, Adapter auto const & document) const {
+    auto is_equal = [this, &document](auto const & frozen) {
+      return document.equals(frozen, cfg_.strict_equality);
+    };
+    if (cons.value->apply(is_equal)) {
+      return result(Status::Accept);
+    }
+    return result(Status::Reject, cons.value, " was expected");
+  }
+
   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);