jsonschema_error.h

#ifndef SOURCEMETA_CORE_JSONSCHEMA_ERROR_H
#define SOURCEMETA_CORE_JSONSCHEMA_ERROR_H
 
#ifndef SOURCEMETA_CORE_JSONSCHEMA_EXPORT
#include <sourcemeta/core/jsonschema_export.h>
#endif
 
#include <sourcemeta/core/jsonpointer.h>
 
#include <cstdint>     // std::uint64_t
#include <exception>   // std::exception
#include <string>      // std::string
#include <string_view> // std::string_view
 
namespace sourcemeta::core {
 
// Exporting symbols that depends on the standard C++ library is considered
// safe.
// https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4275?view=msvc-170&redirectedfrom=MSDN
#if defined(_MSC_VER)
#pragma warning(disable : 4251 4275)
#endif

class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaError : public std::exception {
public:
  SchemaError(const char *message) : message_{message} {}
  SchemaError(std::string message) = delete;
  SchemaError(std::string &&message) = delete;
  SchemaError(std::string_view message) = delete;
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return this->message_;
  }
 
private:
  const char *message_;
};

class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaResolutionError
    : public std::exception {
public:
  SchemaResolutionError(const std::string_view identifier, const char *message)
      : identifier_{identifier}, message_{message} {}
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return this->message_;
  }

  [[nodiscard]] auto identifier() const noexcept -> std::string_view {
    return this->identifier_;
  }
 
private:
  std::string identifier_;
  const char *message_;
};

class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaRelativeMetaschemaResolutionError
    : public SchemaResolutionError {
public:
  SchemaRelativeMetaschemaResolutionError(const std::string_view identifier)
      : SchemaResolutionError{identifier,
                              "Relative meta-schema URIs are not valid "
                              "according to the JSON Schema specification"} {}
};

class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaVocabularyError
    : public std::exception {
public:
  SchemaVocabularyError(const std::string_view uri, const char *message)
      : uri_{uri}, message_{message} {}
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return this->message_;
  }

  [[nodiscard]] auto uri() const noexcept -> std::string_view {
    return this->uri_;
  }
 
private:
  std::string uri_;
  const char *message_;
};

class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaReferenceError
    : public std::exception {
public:
  SchemaReferenceError(const std::string_view identifier,
                       sourcemeta::core::Pointer schema_location,
                       const char *message)
      : identifier_{identifier}, schema_location_{std::move(schema_location)},
        message_{message} {}
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return this->message_;
  }

  [[nodiscard]] auto identifier() const noexcept -> std::string_view {
    return this->identifier_;
  }

  [[nodiscard]] auto location() const noexcept
      -> const sourcemeta::core::Pointer & {
    return this->schema_location_;
  }
 
private:
  std::string identifier_;
  sourcemeta::core::Pointer schema_location_;
  const char *message_;
};

class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaUnknownDialectError
    : public std::exception {
public:
  SchemaUnknownDialectError() = default;
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return "Could not determine the dialect of the schema";
  }
};

class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaUnknownBaseDialectError
    : public std::exception {
public:
  SchemaUnknownBaseDialectError() = default;
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return "Could not determine the base dialect of the schema";
  }
};

class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaReferenceObjectResourceError
    : public std::exception {
public:
  SchemaReferenceObjectResourceError(const std::string_view identifier)
      : identifier_{identifier} {}
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return "A schema with a top-level `$ref` in JSON Schema Draft 7 and older "
           "dialects ignores every sibling keywords (like identifiers and "
           "meta-schema declarations) and therefore many operations, like "
           "bundling, are not possible without undefined behavior";
  }

  [[nodiscard]] auto identifier() const noexcept -> std::string_view {
    return this->identifier_;
  }
 
private:
  std::string identifier_;
};

class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaKeywordError
    : public std::exception {
public:
  SchemaKeywordError(const std::string_view keyword,
                     const std::string_view value, const char *message)
      : keyword_{keyword}, value_{value}, message_{message} {}
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return this->message_;
  }

  [[nodiscard]] auto value() const noexcept -> std::string_view {
    return this->value_;
  }

  [[nodiscard]] auto keyword() const noexcept -> std::string_view {
    return this->keyword_;
  }
 
private:
  std::string keyword_;
  std::string value_;
  const char *message_;
};

class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaFrameError
    : public std::exception {
public:
  SchemaFrameError(const std::string_view identifier, const char *message)
      : identifier_{identifier}, message_{message} {}
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return this->message_;
  }

  [[nodiscard]] auto identifier() const noexcept -> std::string_view {
    return this->identifier_;
  }
 
private:
  std::string identifier_;
  const char *message_;
};

class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaFrameLimitError
    : public std::exception {
public:
  SchemaFrameLimitError(const std::uint64_t limit) : limit_{limit} {}
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return "The schema exceeds the maximum number of frame locations";
  }

  [[nodiscard]] auto limit() const noexcept -> std::uint64_t {
    return this->limit_;
  }
 
private:
  std::uint64_t limit_;
};

class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaAnchorCollisionError
    : public std::exception {
public:
  SchemaAnchorCollisionError(const std::string_view identifier,
                             sourcemeta::core::Pointer location,
                             sourcemeta::core::Pointer other)
      : identifier_{identifier}, location_(std::move(location)),
        other_(std::move(other)) {}
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return "Schema anchor already exists";
  }

  [[nodiscard]] auto identifier() const noexcept -> std::string_view {
    return this->identifier_;
  }

  [[nodiscard]] auto location() const noexcept
      -> const sourcemeta::core::Pointer & {
    return this->location_;
  }

  [[nodiscard]] auto other() const noexcept
      -> const sourcemeta::core::Pointer & {
    return this->other_;
  }
 
private:
  std::string identifier_;
  sourcemeta::core::Pointer location_;
  sourcemeta::core::Pointer other_;
};
 
#if defined(_MSC_VER)
#pragma warning(default : 4251 4275)
#endif
 
} // namespace sourcemeta::core
 
#endif