error.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <map>
#include <optional>
#include <stdexcept>
#include <string>
#include <utility>
#include <variant>
 
namespace pineforge::hpo {
 
enum class FailureOrigin : std::uint8_t { Hpo, Engine };
 
class ErrorArgument {
public:
    using Value =
        std::variant<std::nullptr_t, bool, std::int64_t, std::uint64_t, double, std::string>;
    ErrorArgument(std::nullptr_t value) : value_(value) {}
    ErrorArgument(bool value) : value_(value) {}
    ErrorArgument(std::int64_t value) : value_(value) {}
    ErrorArgument(std::uint64_t value) : value_(value) {}
    ErrorArgument(double value) : value_(value) {}
    ErrorArgument(const char* value) : value_(std::string(value)) {}
    ErrorArgument(std::string value) : value_(std::move(value)) {}
    const Value& value() const noexcept { return value_; }
 
private:
    Value value_;
};
 
using ErrorArguments = std::map<std::string, ErrorArgument>;
 
class HpoError {
public:
    HpoError(std::string code, ErrorArguments args = {}, FailureOrigin origin = FailureOrigin::Hpo)
        : code_(std::move(code)), args_(std::move(args)), origin_(origin) {}
    virtual ~HpoError() = default;
    virtual const char* what() const noexcept = 0;
    const std::string& code() const noexcept { return code_; }
    const ErrorArguments& args() const noexcept { return args_; }
    FailureOrigin origin() const noexcept { return origin_; }
 
private:
    std::string code_;
    ErrorArguments args_;
    FailureOrigin origin_;
};
 
template <typename Base = std::runtime_error>
class TypedHpoError : public Base, public HpoError {
public:
    TypedHpoError(std::string code,
                  ErrorArguments args,
                  const std::string& message,
                  FailureOrigin origin = FailureOrigin::Hpo)
        : Base(message), HpoError(std::move(code), std::move(args), origin) {}
    const char* what() const noexcept override { return Base::what(); }
};
 
class EngineError : public TypedHpoError<> {
public:
    EngineError(std::optional<std::string> code,
                std::optional<std::string> args,
                const std::string& message)
        : TypedHpoError<>(code.value_or(""), {}, message, FailureOrigin::Engine),
          raw_args_(std::move(args)) {}
    const std::optional<std::string>& raw_args() const noexcept { return raw_args_; }
 
private:
    std::optional<std::string> raw_args_;
};
 
}  // namespace pineforge::hpo