error.h

Go to the documentation of this file.

#pragma once
 
#include <stdexcept>
#include <string>
#include <utility>
 
// `<expected>` ships in libstdc++ 14 / libc++ 17, but only enables the
// `std::expected` templates when the compiler meets internal concept /
// constexpr gates. Include the header first (`__has_include` only checks
// for file existence) and then check `__cpp_lib_expected` — that macro is
// defined by `<expected>` itself iff the templates were actually exposed,
// so it stays consistent across g++ and clang-tidy parse paths.
#if __has_include(<expected>)
#include <expected>
#endif
 
#if defined(__cpp_lib_expected) && __cpp_lib_expected >= 202202L
#define PARCEL_HAS_EXPECTED 1
#else
#define PARCEL_HAS_EXPECTED 0
#endif
 
namespace parcel {
 
struct ParcelError {
    enum class Code {
        InvalidJson,
        KindMismatch,
        UnknownKind,
        MissingField,
        TypeError,
    };
 
    Code code{Code::InvalidJson};
    std::string message;
    std::string kind;
    std::string field;
 
    [[nodiscard]] std::string to_string() const {
        std::string out;
        switch (code) {
        case Code::InvalidJson:
            out = "InvalidJson";
            break;
        case Code::KindMismatch:
            out = "KindMismatch";
            break;
        case Code::UnknownKind:
            out = "UnknownKind";
            break;
        case Code::MissingField:
            out = "MissingField";
            break;
        case Code::TypeError:
            out = "TypeError";
            break;
        }
        out += ": ";
        out += message;
        if (!kind.empty()) {
            out += " [kind=";
            out += kind;
            out += "]";
        }
        if (!field.empty()) {
            out += " [field=";
            out += field;
            out += "]";
        }
        return out;
    }
 
    static ParcelError
    make(const Code c, std::string msg, std::string kind_id = {}, std::string fld = {}) {
        return ParcelError{c, std::move(msg), std::move(kind_id), std::move(fld)};
    }
};
 
class ParcelException : public std::runtime_error {
public:
    // std::runtime_error only takes a const-ref string, so msg is necessarily
    // copied into the base sub-object — pass-by-value-then-move would buy us
    // nothing here. Adjacent string params are intentional and used by every
    // derived class.
    // NOLINTBEGIN(bugprone-easily-swappable-parameters,performance-unnecessary-value-param)
    ParcelException(const ParcelError::Code c,
                    const std::string& msg,
                    std::string kind_id = {},
                    std::string field_name = {})
        : std::runtime_error(msg), code_(c), kind_(std::move(kind_id)),
          field_(std::move(field_name)) {}
    // NOLINTEND(bugprone-easily-swappable-parameters,performance-unnecessary-value-param)
 
    [[nodiscard]] ParcelError::Code code() const noexcept {
        return code_;
    }
    [[nodiscard]] std::string_view kind_id() const noexcept {
        return kind_;
    }
    [[nodiscard]] std::string_view field_name() const noexcept {
        return field_;
    }
 
    [[nodiscard]] ParcelError to_error() const {
        return ParcelError::make(code_, what(), kind_, field_);
    }
 
private:
    ParcelError::Code code_;
    std::string kind_;
    std::string field_;
};
 
class InvalidJsonException final : public ParcelException {
public:
    explicit InvalidJsonException(const std::string& msg,
                                  std::string kind_id = {},
                                  std::string field_name = {})
        : ParcelException(
              ParcelError::Code::InvalidJson, msg, std::move(kind_id), std::move(field_name)) {}
};
 
class KindMismatchException final : public ParcelException {
public:
    explicit KindMismatchException(const std::string& msg, std::string kind_id = {})
        : ParcelException(ParcelError::Code::KindMismatch, msg, std::move(kind_id)) {}
};
 
class UnknownKindException final : public ParcelException {
public:
    explicit UnknownKindException(const std::string& msg, std::string kind_id = {})
        : ParcelException(ParcelError::Code::UnknownKind, msg, std::move(kind_id)) {}
};
 
class MissingFieldException final : public ParcelException {
public:
    MissingFieldException(const std::string& msg, std::string kind_id, std::string field_name)
        : ParcelException(
              ParcelError::Code::MissingField, msg, std::move(kind_id), std::move(field_name)) {}
};
 
class TypeException final : public ParcelException {
public:
    explicit TypeException(const std::string& msg,
                           std::string kind_id = {},
                           std::string field_name = {})
        : ParcelException(
              ParcelError::Code::TypeError, msg, std::move(kind_id), std::move(field_name)) {}
};
 
}  // namespace parcel