uritemplate_error.h

#ifndef SOURCEMETA_CORE_URITEMPLATE_ERROR_H_
#define SOURCEMETA_CORE_URITEMPLATE_ERROR_H_
 
#ifndef SOURCEMETA_CORE_URITEMPLATE_EXPORT
#include <sourcemeta/core/uritemplate_export.h>
#endif
 
#include <cstdint>     // std::uint64_t
#include <exception>   // std::exception
#include <filesystem>  // std::filesystem::path
#include <stdexcept>   // std::runtime_error
#include <string>      // std::string
#include <string_view> // std::string_view
#include <utility>     // std::move
 
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_URITEMPLATE_EXPORT URITemplateParseError
    : public std::exception {
public:
  URITemplateParseError(const std::uint64_t column) : column_{column} {}
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return "The input is not a valid URI Template";
  }

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

class SOURCEMETA_CORE_URITEMPLATE_EXPORT URITemplateExpansionError
    : public std::runtime_error {
public:
  URITemplateExpansionError(const std::string &message)
      : std::runtime_error{message} {}
};

class SOURCEMETA_CORE_URITEMPLATE_EXPORT URITemplateRouterVariableMismatchError
    : public std::exception {
public:
  URITemplateRouterVariableMismatchError(const std::string_view left,
                                         const std::string_view right)
      : left_{left}, right_{right} {}
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return "Variable name mismatch when adding route";
  }

  [[nodiscard]] auto left() const noexcept -> const std::string & {
    return this->left_;
  }

  [[nodiscard]] auto right() const noexcept -> const std::string & {
    return this->right_;
  }
 
private:
  std::string left_;
  std::string right_;
};

class SOURCEMETA_CORE_URITEMPLATE_EXPORT URITemplateRouterInvalidSegmentError
    : public std::exception {
public:
  URITemplateRouterInvalidSegmentError(const char *message,
                                       const std::string_view segment)
      : message_{message}, segment_{segment} {}
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return this->message_;
  }

  [[nodiscard]] auto segment() const noexcept -> const std::string & {
    return this->segment_;
  }
 
private:
  const char *message_;
  std::string segment_;
};

class SOURCEMETA_CORE_URITEMPLATE_EXPORT
    URITemplateRouterInvalidOperationIdError : public std::exception {
public:
  URITemplateRouterInvalidOperationIdError(const std::string_view operation_id)
      : operation_id_{operation_id} {}
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return "Invalid operation identifier";
  }

  [[nodiscard]] auto operation_id() const noexcept -> const std::string & {
    return this->operation_id_;
  }
 
private:
  std::string operation_id_;
};

class SOURCEMETA_CORE_URITEMPLATE_EXPORT
    URITemplateRouterDuplicateOperationIdError : public std::exception {
public:
  URITemplateRouterDuplicateOperationIdError(
      const std::string_view operation_id)
      : operation_id_{operation_id} {}
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return "Duplicate operation identifier";
  }

  [[nodiscard]] auto operation_id() const noexcept -> const std::string & {
    return this->operation_id_;
  }
 
private:
  std::string operation_id_;
};

class SOURCEMETA_CORE_URITEMPLATE_EXPORT URITemplateRouterSaveError
    : public std::exception {
public:
  URITemplateRouterSaveError(std::filesystem::path path, const char *message)
      : path_{std::move(path)}, message_{message} {}
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return this->message_;
  }

  [[nodiscard]] auto path() const noexcept -> const std::filesystem::path & {
    return this->path_;
  }
 
private:
  std::filesystem::path path_;
  const char *message_;
};

class SOURCEMETA_CORE_URITEMPLATE_EXPORT URITemplateRouterReadError
    : public std::exception {
public:
  URITemplateRouterReadError(std::filesystem::path path)
      : path_{std::move(path)} {}
 
  [[nodiscard]] auto what() const noexcept -> const char * override {
    return "Failed to open router file for reading";
  }

  [[nodiscard]] auto path() const noexcept -> const std::filesystem::path & {
    return this->path_;
  }
 
private:
  std::filesystem::path path_;
};
 
#if defined(_MSC_VER)
#pragma warning(default : 4251 4275)
#endif
 
} // namespace sourcemeta::core
 
#endif