compiler_error.h

#ifndef SOURCEMETA_BLAZE_COMPILER_ERROR_H
#define SOURCEMETA_BLAZE_COMPILER_ERROR_H
 
#ifndef SOURCEMETA_BLAZE_COMPILER_EXPORT
#include <sourcemeta/blaze/compiler_export.h>
#endif
 
#include <sourcemeta/core/jsonpointer.h>
#include <sourcemeta/core/uri.h>
 
#include <cstdint>     // std::uint64_t
#include <exception>   // std::exception
#include <string>      // std::string
#include <string_view> // std::string_view
#include <utility>     // std::move
 
namespace sourcemeta::blaze {
 
// 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_BLAZE_COMPILER_EXPORT CompilerError : public std::exception {
public:
  CompilerError(sourcemeta::core::URI base,
                sourcemeta::core::Pointer schema_location, const char *message)
      : base_{std::move(base)}, schema_location_{std::move(schema_location)},
        message_{message} {}
  CompilerError(sourcemeta::core::URI base,
                sourcemeta::core::Pointer schema_location,
                std::string message) = delete;
  CompilerError(sourcemeta::core::URI base,
                sourcemeta::core::Pointer schema_location,
                std::string &&message) = delete;
  CompilerError(sourcemeta::core::URI base,
                sourcemeta::core::Pointer schema_location,
                std::string_view message) = delete;
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return this->message_;
  }
 
  [[nodiscard]] auto base() const noexcept -> const sourcemeta::core::URI & {
    return this->base_;
  }

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

class SOURCEMETA_BLAZE_COMPILER_EXPORT CompilerInvalidRegexError
    : public std::exception {
public:
  CompilerInvalidRegexError(sourcemeta::core::URI base,
                            sourcemeta::core::Pointer schema_location,
                            std::string regex)
      : base_{std::move(base)}, schema_location_{std::move(schema_location)},
        regex_{std::move(regex)} {}
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return "Invalid regular expression";
  }
 
  [[nodiscard]] auto base() const noexcept -> const sourcemeta::core::URI & {
    return this->base_;
  }

  [[nodiscard]] auto location() const noexcept
      -> const sourcemeta::core::Pointer & {
    return this->schema_location_;
  }
 
  [[nodiscard]] auto regex() const noexcept -> const std::string & {
    return this->regex_;
  }
 
private:
  sourcemeta::core::URI base_;
  sourcemeta::core::Pointer schema_location_;
  std::string regex_;
};

class SOURCEMETA_BLAZE_COMPILER_EXPORT CompilerReferenceTargetNotSchemaError
    : public std::exception {
public:
  CompilerReferenceTargetNotSchemaError(
      const std::string_view identifier,
      sourcemeta::core::Pointer schema_location)
      : identifier_{identifier}, schema_location_{std::move(schema_location)} {}
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return "The referenced schema is not considered to be a valid subschema "
           "given the dialect and vocabularies in use";
  }
 
  [[nodiscard]] auto identifier() const noexcept -> const std::string & {
    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_;
};

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

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

class SOURCEMETA_BLAZE_COMPILER_EXPORT CompilerDepthLimitError
    : public std::exception {
public:
  CompilerDepthLimitError(const std::uint64_t limit) : limit_{limit} {}
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return "The schema exceeds the maximum compilation depth";
  }

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

class SOURCEMETA_BLAZE_COMPILER_EXPORT CompilerInvalidEntryPoint
    : public std::exception {
public:
  CompilerInvalidEntryPoint(const std::string_view entrypoint,
                            const char *message)
      : identifier_{entrypoint}, message_{message} {}
  CompilerInvalidEntryPoint(const std::string_view entrypoint,
                            std::string message) = delete;
  CompilerInvalidEntryPoint(const std::string_view entrypoint,
                            std::string &&message) = delete;
  CompilerInvalidEntryPoint(const std::string_view entrypoint,
                            std::string_view message) = delete;
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return this->message_;
  }
 
  [[nodiscard]] auto identifier() const noexcept -> const std::string & {
    return this->identifier_;
  }
 
private:
  std::string identifier_;
  const char *message_;
};
 
#if defined(_MSC_VER)
#pragma warning(default : 4251 4275)
#endif
 
} // namespace sourcemeta::blaze
 
#endif