exceptions.hh

Go to the documentation of this file.

/* ========================================================================== *
 *
 * @file flox/core/exceptions.hh
 *
 * @brief Definitions of various `std::exception` children used for throwing
 *        errors with nice messages and typed discrimination.
 *
 *
 * -------------------------------------------------------------------------- */
 
#pragma once
 
#include <nix/nixexpr.hh>
#include <nlohmann/json.hpp>
#include <optional>
#include <stdexcept>
#include <string>
 
 
/* -------------------------------------------------------------------------- */
 
namespace flox {
 
/* -------------------------------------------------------------------------- */
 
enum error_category {
  EC_OKAY = 0,
  EC_FAILURE = 1,
  EC_FLOX_EXCEPTION = 100,
  EC_INVALID_ARG,
  EC_INVALID_MANIFEST_DESCRIPTOR,
  EC_INVALID_PKG_QUERY_ARG,
  EC_INVALID_REGISTRY,
  EC_INVALID_MANIFEST_FILE,
  EC_NIX,
  EC_NIX_EVAL,
  EC_NIX_LOCK_FLAKE,
  EC_PACKAGE_INIT,
  EC_PARSE_MANIFEST_DESCRIPTOR_RAW,
  EC_PARSE_RESOLVED,
  EC_PARSE_SEARCH_QUERY,
  EC_PKG_DB,
  EC_SQLITE3,
  EC_JSON,
  EC_TOML_TO_JSON,
  EC_YAML_TO_JSON,
  EC_INVALID_LOCKFILE,
  EC_INVALID_HASH,
  EC_RESOLUTION_FAILURE,
  EC_ENVIRONMENT_MIXIN
 
}; /* End enum `error_category' */
 
 
/* -------------------------------------------------------------------------- */
 
class FloxException : public std::exception
{
 
private:
 
  std::optional<std::string> contextMsg;
 
  std::optional<std::string> caughtMsg;
 
  std::string whatMsg;
 
 
public:
 
  explicit FloxException( std::string_view contextMsg )
    : contextMsg( contextMsg )
    , whatMsg( "general error: " + std::string( contextMsg ) )
  {}
 
  explicit FloxException( std::string_view contextMsg,
                          std::string_view caughtMsg )
    : contextMsg( contextMsg )
    , caughtMsg( caughtMsg )
    , whatMsg( "general error: " + std::string( contextMsg ) + ": "
               + std::string( caughtMsg ) )
  {}
 
  explicit FloxException( std::string_view           categoryMsg,
                          std::optional<std::string> contextMsg,
                          std::optional<std::string> caughtMsg )
    : contextMsg( contextMsg ), caughtMsg( caughtMsg ), whatMsg( categoryMsg )
  {
    /* Finish initializing `categoryMsg` if we received `contextMsg` or
     * `caughtMsg` values. */
    if ( contextMsg.has_value() ) { this->whatMsg += ": " + ( *contextMsg ); }
    if ( caughtMsg.has_value() ) { this->whatMsg += ": " + ( *caughtMsg ); }
  }
 
 
  [[nodiscard]] virtual error_category
  getErrorCode() const noexcept
  {
    return EC_FLOX_EXCEPTION;
  }
 
  [[nodiscard]] std::optional<std::string>
  getContextMessage() const noexcept
  {
    return this->contextMsg;
  }
 
  [[nodiscard]] std::optional<std::string>
  getCaughtMessage() const noexcept
  {
    return this->caughtMsg;
  }
 
  [[nodiscard]] virtual std::string_view
  getCategoryMessage() const noexcept
  {
    return "general error";
  }
 
  [[nodiscard]] const char *
  what() const noexcept override
  {
    return this->whatMsg.c_str();
  }
 
 
}; /* End class `FloxException' */
 
 
/* -------------------------------------------------------------------------- */
 
void
to_json( nlohmann::json & jto, const FloxException & err );
 
 
/* -------------------------------------------------------------------------- */
 
// NOLINTBEGIN(bugprone-macro-parentheses)
//  Disable macro parentheses lint so we can use `NAME' symbol directly.
 
#define FLOX_DEFINE_EXCEPTION( NAME, ERROR_CODE, CATEGORY_MSG )              \
  class NAME : public FloxException                                          \
  {                                                                          \
  public:                                                                    \
                                                                             \
    NAME() : FloxException( CATEGORY_MSG, std::nullopt, std::nullopt ) {}    \
                                                                             \
    explicit NAME( std::string_view contextMsg )                             \
      : FloxException( ( CATEGORY_MSG ),                                     \
                       std::string( contextMsg ),                            \
                       std::nullopt )                                        \
    {}                                                                       \
                                                                             \
    explicit NAME( std::string_view contextMsg, std::string_view caughtMsg ) \
      : FloxException( ( CATEGORY_MSG ),                                     \
                       std::string( contextMsg ),                            \
                       std::string( caughtMsg ) )                            \
    {}                                                                       \
                                                                             \
    [[nodiscard]] error_category                                             \
    getErrorCode() const noexcept override                                   \
    {                                                                        \
      return ( ERROR_CODE );                                                 \
    }                                                                        \
                                                                             \
    [[nodiscard]] std::string_view                                           \
    getCategoryMessage() const noexcept override                             \
    {                                                                        \
      return ( CATEGORY_MSG );                                               \
    }                                                                        \
  };
// NOLINTEND(bugprone-macro-parentheses)
 
 
/* -------------------------------------------------------------------------- */
 
class NixEvalException : public FloxException
{
 
public:
 
  explicit NixEvalException( std::string_view       contextMsg,
                             const nix::EvalError & err )
    : FloxException( "invalid argument",
                     std::string( contextMsg ),
                     nix::filterANSIEscapes( err.what(), true ) )
  {}
 
  [[nodiscard]] error_category
  getErrorCode() const noexcept override
  {
    return EC_NIX_EVAL;
  }
 
  [[nodiscard]] std::string_view
  getCategoryMessage() const noexcept override
  {
    return "Nix evaluation error";
  }
 
 
}; /* End class `NixEvalException' */
 
 
/* -------------------------------------------------------------------------- */
 
// TODO: wrap usage of `nix::flake::Fingerprint' with these.
FLOX_DEFINE_EXCEPTION( InvalidHashException, EC_INVALID_HASH, "invalid hash" )
/* -------------------------------------------------------------------------- */
 
}  // namespace flox
 
 
/* -------------------------------------------------------------------------- *
 *
 *
 *
 * ========================================================================== */