json-validator/include/jvalidate/forward.h

#pragma once

#include <functional>
#include <string>

namespace jvalidate {
class Schema;
class Status;
struct ValidationConfig;
class ValidationResult;
}

namespace jvalidate::adapter {
enum class Type : int8_t;
class Adapter;
class Const;

using AdapterCallback = std::function<Status(adapter::Adapter const &)>;
using ObjectAdapterCallback = std::function<Status(std::string const &, adapter::Adapter const &)>;

template <typename> struct AdapterTraits;
template <typename V> struct AdapterTraits<V const> : AdapterTraits<V> {};

template <typename JSON> using AdapterFor = typename AdapterTraits<JSON>::template Adapter<JSON>;
}

namespace jvalidate::constraint {
class ConstraintVisitor;
class Constraint;
template <typename> class SimpleConstraint;
class ExtensionConstraint;

class TypeConstraint;
class EnumConstraint;
class AllOfConstraint;
class AnyOfConstraint;
class OneOfConstraint;
class NotConstraint;
class ConditionalConstraint;

class MaximumConstraint;
class MinimumConstraint;
class MultipleOfConstraint;

class MaxLengthConstraint;
class MinLengthConstraint;
class PatternConstraint;

class AdditionalItemsConstraint;
class ContainsConstraint;
class MaxItemsConstraint;
class MinItemsConstraint;
class TupleConstraint;
class UnevaluatedItemsConstraint;
class UniqueItemsConstraint;

class AdditionalPropertiesConstraint;
class DependenciesConstraint;
class MaxPropertiesConstraint;
class MinPropertiesConstraint;
class PatternPropertiesConstraint;
class PropertiesConstraint;
class PropertyNamesConstraint;
class RequiredConstraint;
class UnevaluatedPropertiesConstraint;
}

namespace jvalidate::schema {
enum class Version : int;
class Node;
}

namespace jvalidate {
template <typename It>
concept ArrayIterator = std::forward_iterator<It> and std::is_default_constructible_v<It> and
    requires(It const it) {
  { *it } -> std::convertible_to<adapter::Adapter const &>;
};

template <typename It>
concept ObjectIterator = std::forward_iterator<It> and std::is_default_constructible_v<It> and
    requires(It const it) {
  { it->first } -> std::convertible_to<std::string_view>;
  { it->second } -> std::convertible_to<adapter::Adapter const &>;
};

template <typename A>
concept ArrayAdapter = requires(A const a) {
  { a.size() } -> std::convertible_to<std::size_t>;
  { a[0UL] } -> std::convertible_to<adapter::Adapter const &>;
  { a.begin() } -> ArrayIterator;
  { a.end() } -> ArrayIterator;
};

template <typename A>
concept ObjectAdapter = requires(A const a) {
  { a.size() } -> std::convertible_to<std::size_t>;
  { a.contains("") } -> std::same_as<bool>;
  { a[""] } -> std::convertible_to<adapter::Adapter const &>;
  { a.begin() } -> ObjectIterator;
  { a.end() } -> ObjectIterator;
};

template <typename A>
concept Adapter = std::is_base_of_v<adapter::Adapter, A> && requires(A const a) {
  { a.type() } -> std::same_as<adapter::Type>;
  { a.as_boolean() } -> std::same_as<bool>;
  { a.as_integer() } -> std::convertible_to<int64_t>;
  { a.as_number() } -> std::convertible_to<double>;
  { a.as_number() } -> std::floating_point;
  { a.as_object() } -> ObjectAdapter;
  { a.as_array() } -> ArrayAdapter;

  { a.array_size() } -> std::convertible_to<size_t>;
  { a.object_size() } -> std::convertible_to<size_t>;
};

template <typename A>
concept MutableObject = ObjectAdapter<A> && requires(A const a) {
  {a.assign("", std::declval<adapter::Const>())};
};

template <typename A>
concept MutableAdapter = Adapter<A> && requires(A const a) {
  {a.assign(std::declval<adapter::Const>())};
  {a.assign(std::declval<adapter::Adapter>())};
  { a.as_object() } -> MutableObject;
};

template <typename R>
concept RegexEngine = std::constructible_from<std::string> && requires(R const regex) {
  { regex.search("") } -> std::same_as<bool>;
};
}

namespace jvalidate {
template <Adapter A> class ConstraintFactory;
template <Adapter A, RegexEngine RE> class ValidationVisitor;

template <RegexEngine RE> class ValidatorT;
class Validator;
}