jsonschema_types.h

#ifndef SOURCEMETA_CORE_JSONSCHEMA_TYPES_H_
#define SOURCEMETA_CORE_JSONSCHEMA_TYPES_H_
 
#include <sourcemeta/core/json.h>
#include <sourcemeta/core/jsonpointer.h>
#include <sourcemeta/core/jsonschema_vocabularies.h>
#include <sourcemeta/core/memory.h>
 
#include <cstdint>     // std::uint8_t
#include <format>      // std::formatter, std::format_to
#include <functional>  // std::function, std::reference_wrapper
#include <optional>    // std::optional
#include <ostream>     // std::ostream
#include <span>        // std::span
#include <sstream>     // std::ostringstream
#include <string>      // std::string
#include <string_view> // std::string_view
 
namespace sourcemeta::core {

using SchemaResolverResult =
    sourcemeta::core::OwnedOrReference<sourcemeta::core::JSON>;

using SchemaResolver = std::function<SchemaResolverResult(std::string_view)>;

enum class SchemaReferenceType : std::uint8_t {
  Static,
  Dynamic
};

enum class SchemaBaseDialect : std::uint8_t {
  JSON_SCHEMA_2020_12,
  JSON_SCHEMA_2020_12_HYPER,
  JSON_SCHEMA_2019_09,
  JSON_SCHEMA_2019_09_HYPER,
  JSON_SCHEMA_DRAFT_7,
  JSON_SCHEMA_DRAFT_7_HYPER,
  JSON_SCHEMA_DRAFT_6,
  JSON_SCHEMA_DRAFT_6_HYPER,
  JSON_SCHEMA_DRAFT_4,
  JSON_SCHEMA_DRAFT_4_HYPER,
  JSON_SCHEMA_DRAFT_3,
  JSON_SCHEMA_DRAFT_3_HYPER,
  JSON_SCHEMA_DRAFT_2_HYPER,
  JSON_SCHEMA_DRAFT_1_HYPER,
  JSON_SCHEMA_DRAFT_0_HYPER
};

SOURCEMETA_CORE_JSONSCHEMA_EXPORT
auto operator<<(std::ostream &stream, const SchemaBaseDialect base_dialect)
    -> std::ostream &;
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
// For some strange reason, GCC on Debian 11 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 SchemaKeywordType : std::uint8_t {
  Unknown,
  Assertion,
  Annotation,
  Reference,
  Other,
  Comment,
  LocationMembers,

  ApplicatorMembersTraversePropertyStatic,
  ApplicatorMembersTraversePropertyRegex,
  ApplicatorValueTraverseSomeProperty,
  ApplicatorValueTraverseAnyPropertyKey,
  ApplicatorValueTraverseAnyItem,
  ApplicatorValueTraverseSomeItem,
  ApplicatorValueTraverseParent,
  ApplicatorElementsTraverseItem,
  ApplicatorValueOrElementsTraverseAnyItemOrItem,
  ApplicatorValueOrElementsInPlace,
  ApplicatorMembersInPlaceSome,
  ApplicatorElementsInPlace,
  ApplicatorElementsInPlaceSome,
  ApplicatorElementsInPlaceSomeNegate,
  ApplicatorValueInPlaceMaybe,
  ApplicatorValueInPlaceOther,
  ApplicatorValueInPlaceNegate,
};
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif

struct SchemaWalkerResult {
  SchemaKeywordType type;
  std::optional<SchemaVocabularies::URIView> vocabulary;
  std::span<const std::string_view> dependencies;
  std::span<const std::string_view> order_dependencies;
  sourcemeta::core::JSON::TypeSet instances;
 
  // Prevent accidental copies, as walker results are always returned by
  // reference
  SchemaWalkerResult(const SchemaWalkerResult &) = delete;
  auto operator=(const SchemaWalkerResult &) -> SchemaWalkerResult & = delete;
  SchemaWalkerResult(SchemaWalkerResult &&) = default;
  auto operator=(SchemaWalkerResult &&) -> SchemaWalkerResult & = default;
  ~SchemaWalkerResult() = default;

  constexpr SchemaWalkerResult(
      SchemaKeywordType keyword_type,
      std::optional<SchemaVocabularies::URIView> keyword_vocabulary,
      std::span<const std::string_view> keyword_dependencies,
      std::span<const std::string_view> keyword_order_dependencies,
      sourcemeta::core::JSON::TypeSet keyword_instances)
      : type{keyword_type}, vocabulary{keyword_vocabulary},
        dependencies{keyword_dependencies},
        order_dependencies{keyword_order_dependencies},
        instances{keyword_instances} {}
};

using SchemaWalker = std::function<const SchemaWalkerResult &(
    std::string_view, const SchemaVocabularies &)>;
 
} // namespace sourcemeta::core

template <> struct std::formatter<sourcemeta::core::SchemaBaseDialect> {
  constexpr auto parse(std::format_parse_context &context)
      -> decltype(context.begin()) {
    return context.begin();
  }
 
  auto format(const sourcemeta::core::SchemaBaseDialect value,
              std::format_context &context) const -> decltype(context.out()) {
    std::ostringstream stream;
    stream << value;
    return std::format_to(context.out(), "{}", stream.str());
  }
};
 
#endif