error_handling.hpp

Go to the documentation of this file.

#pragma once
 
#include "../connection/connection.hpp"
#include "../query/core.hpp"
#include "../results/result.hpp"
 
#include <expected>
#include <format>
#include <source_location>
#include <stdexcept>
#include <string>
 
namespace relx {
 
class RelxException : public std::runtime_error {
public:
  explicit RelxException(const std::string& message,
                         const std::source_location& location = std::source_location::current())
      : std::runtime_error(
            std::format("[{}:{}] {}", location.file_name(), location.line(), message)) {}
};
 
inline std::string format_error(const connection::ConnectionError& error) {
  return std::format("Connection error: {} (Code: {})", error.message, error.error_code);
}
 
inline std::string format_error(const query::QueryError& error) {
  return std::format("Query error: {}", error.message);
}
 
inline std::string format_error(const result::ResultError& error) {
  return std::format("Result processing error: {}", error.message);
}
 
template <typename T, typename E>
T& value_or_throw(std::expected<T, E>& result, const std::string& context = "",
                  const std::source_location& location = std::source_location::current()) {
  if (!result) {
    std::string message;
    if (!context.empty()) {
      message = std::format("{}: ", context);
    }
    message += format_error(result.error());
    throw RelxException(message, location);
  }
  return result.value();
}
 
template <typename T, typename E>
T value_or_throw(std::expected<T, E>&& result, const std::string& context = "",
                 const std::source_location& location = std::source_location::current()) {
  if (!result) {
    std::string message;
    if (!context.empty()) {
      message = std::format("{}: ", context);
    }
    message += format_error(result.error());
    throw RelxException(message, location);
  }
  return std::move(result.value());
}
 
template <typename E>
void throw_if_failed(const std::expected<void, E>& result, const std::string& context = "",
                     const std::source_location& location = std::source_location::current()) {
  if (!result) {
    std::string message;
    if (!context.empty()) {
      message = std::format("{}: ", context);
    }
    message += format_error(result.error());
    throw RelxException(message, location);
  }
}
 
}  // namespace relx