jsonschema_vocabularies.h

#ifndef SOURCEMETA_CORE_JSONSCHEMA_VOCABULARIES_H_
#define SOURCEMETA_CORE_JSONSCHEMA_VOCABULARIES_H_
 
#ifndef SOURCEMETA_CORE_JSONSCHEMA_EXPORT
#include <sourcemeta/core/jsonschema_export.h>
#endif
 
#include <sourcemeta/core/json.h>
 
#include <bitset>  // std::bitset
#include <cassert> // assert
#include <cstdint> // std::uint32_t, std::size_t
#include <format> // std::formatter, std::format_context, std::format_parse_context, std::format_to
#include <optional>      // std::optional
#include <ostream>       // std::ostream
#include <sstream>       // std::ostringstream
#include <stdexcept>     // std::out_of_range
#include <string_view>   // std::string_view
#include <unordered_map> // std::unordered_map
#include <unordered_set> // std::unordered_set
#include <utility>       // std::pair
#include <variant>       // std::variant
#include <vector>        // std::vector
 
namespace sourcemeta::core {

struct SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaVocabularies {
  enum class Known : std::uint8_t {
    // Pre-vocabulary dialects (treated as vocabularies)
    JSON_SCHEMA_DRAFT_0 = 0,
    JSON_SCHEMA_DRAFT_0_HYPER = 1,
    JSON_SCHEMA_DRAFT_1 = 2,
    JSON_SCHEMA_DRAFT_1_HYPER = 3,
    JSON_SCHEMA_DRAFT_2 = 4,
    JSON_SCHEMA_DRAFT_2_HYPER = 5,
    JSON_SCHEMA_DRAFT_3 = 6,
    JSON_SCHEMA_DRAFT_3_HYPER = 7,
    JSON_SCHEMA_DRAFT_4 = 8,
    JSON_SCHEMA_DRAFT_4_HYPER = 9,
    JSON_SCHEMA_DRAFT_6 = 10,
    JSON_SCHEMA_DRAFT_6_HYPER = 11,
    JSON_SCHEMA_DRAFT_7 = 12,
    JSON_SCHEMA_DRAFT_7_HYPER = 13,
    // 2019-09 vocabularies
    JSON_SCHEMA_2019_09_CORE = 14,
    JSON_SCHEMA_2019_09_APPLICATOR = 15,
    JSON_SCHEMA_2019_09_VALIDATION = 16,
    JSON_SCHEMA_2019_09_META_DATA = 17,
    JSON_SCHEMA_2019_09_FORMAT = 18,
    JSON_SCHEMA_2019_09_CONTENT = 19,
    JSON_SCHEMA_2019_09_HYPER_SCHEMA = 20,
    // 2020-12 vocabularies
    JSON_SCHEMA_2020_12_CORE = 21,
    JSON_SCHEMA_2020_12_APPLICATOR = 22,
    JSON_SCHEMA_2020_12_UNEVALUATED = 23,
    JSON_SCHEMA_2020_12_VALIDATION = 24,
    JSON_SCHEMA_2020_12_META_DATA = 25,
    JSON_SCHEMA_2020_12_FORMAT_ANNOTATION = 26,
    JSON_SCHEMA_2020_12_FORMAT_ASSERTION = 27,
    JSON_SCHEMA_2020_12_CONTENT = 28,
    // OpenAPI
    // https://spec.openapis.org/oas/v3.1.0.html#fixed-fields-19
    OPENAPI_3_1_BASE = 29,
    // https://spec.openapis.org/oas/v3.2.0.html#base-vocabulary
    OPENAPI_3_2_BASE = 30,
    // Sourcemeta
    SOURCEMETA_EXTENSION_V1 = 31
  };
 
  // NOTE: Must be kept in sync with the Known enum above
  static constexpr std::size_t KNOWN_VOCABULARY_COUNT = 32;

  using URI = std::variant<Known, sourcemeta::core::JSON::String>;

  using URIView = std::variant<Known, std::string_view>;
 
public:
  SchemaVocabularies() = default;
  SchemaVocabularies(const SchemaVocabularies &) = default;
  SchemaVocabularies(SchemaVocabularies &&) noexcept = default;
  auto operator=(const SchemaVocabularies &) -> SchemaVocabularies & = default;
  auto operator=(SchemaVocabularies &&) noexcept
      -> SchemaVocabularies & = default;
  ~SchemaVocabularies() = default;

  SchemaVocabularies(
      std::initializer_list<std::pair<sourcemeta::core::JSON::String, bool>>
          init);

  SchemaVocabularies(std::initializer_list<std::pair<Known, bool>> init);

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

  [[nodiscard]] auto contains(Known vocabulary) const noexcept -> bool;

  [[nodiscard]] auto
  contains_any(std::initializer_list<Known> vocabularies) const noexcept
      -> bool;

  auto insert(const sourcemeta::core::JSON::String &uri, bool required) noexcept
      -> void;

  auto insert(Known vocabulary, bool required) noexcept -> void;

  [[nodiscard]] auto
  get(const sourcemeta::core::JSON::String &uri) const noexcept
      -> std::optional<bool>;

  [[nodiscard]] auto get(Known vocabulary) const noexcept
      -> std::optional<bool>;

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

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

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

  template <typename Callback>
  auto for_each(const Callback &callback) const -> void {
    for (std::size_t index = 0; index < KNOWN_VOCABULARY_COUNT; ++index) {
      if (this->required_known_[index]) {
        callback(URI{static_cast<Known>(index)}, true);
      } else if (this->optional_known_[index]) {
        callback(URI{static_cast<Known>(index)}, false);
      }
    }
 
    if (this->unknown_.has_value()) {
      for (const auto &[uri, required] : this->unknown_.value()) {
        callback(URI{uri}, required);
      }
    }
  }

  auto throw_if_any_unsupported(const std::unordered_set<URI> &supported,
                                const char *message) const -> void;
 
private:
  // Invariant: required_known and optional_known must be mutually exclusive
  // A vocabulary can be either required (true) OR optional (false), never both
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4251)
#endif
  std::bitset<KNOWN_VOCABULARY_COUNT> required_known_{};
  std::bitset<KNOWN_VOCABULARY_COUNT> optional_known_{};
  // Lazily initialized only when unknown (non-official) vocabularies are used
  std::optional<std::unordered_map<sourcemeta::core::JSON::String, bool>>
      unknown_{std::nullopt};
#ifdef _MSC_VER
#pragma warning(pop)
#endif
};

SOURCEMETA_CORE_JSONSCHEMA_EXPORT auto
operator<<(std::ostream &stream, SchemaVocabularies::Known vocabulary)
    -> std::ostream &;

SOURCEMETA_CORE_JSONSCHEMA_EXPORT auto
operator<<(std::ostream &stream, const SchemaVocabularies::URI &vocabulary)
    -> std::ostream &;
 
} // namespace sourcemeta::core

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