exception.hpp

Go to the documentation of this file.

#ifndef IV_SRC_CORE_EXCEPTION_HPP_
#define IV_SRC_CORE_EXCEPTION_HPP_
 
#include <cstdint>
#include <fmt/core.h>
#include <optional>
#include <string_view>
 
namespace iv::exception
{
 
enum class eExceptionType
{
    Unknown = 1,
    SystemError,
    NotImplemented,
    OutOfMemory,
    InternalError,
    IoError,
    SerialPortError,
    FolderNotFound,
    FileNotFound,
    FileNameNotAvailable,
 
    OutOfBoundsMemoryAccess,
    InvalidObjectState = 100,
    KeyNotSet,
    InvalidArgument,
    InvalidKeyLength,
    InvalidNonceLength,
    LookupError,
    EncodingFailure,
    DecodingFailure,
    TLSError,
    HttpError,
    InvalidTag,
    RoughTimeError,
    MissingCase,
 
    CommonCryptoError = 201,
    Pkcs11Error,
    TPMError,
    DatabaseError,
    InvalidFileIntegrity,
 
    LibZipError = 300,
    Bzip2Error,
    LzmaError,
};
 
/***
 * @brief Convert an eExceptionType to string
 * @param type
 * @return
 */
std::string toString(eExceptionType type);
 
class Exception : public std::exception
{
public:
    explicit Exception(const std::string_view msg) : m_msg(msg)
    {
    }
 
    Exception(const char *prefix, std::string_view msg) : m_msg(fmt::format("{} {}", prefix, msg))
    {
    }
 
    Exception(std::string_view msg, const std::exception &e) : m_msg(fmt::format("{} failed with {}", msg, e.what()))
    {
    }
 
    ~Exception() noexcept override = default;
 
    [[nodiscard]] virtual int64_t errorCode() const noexcept
    {
        return 0;
    }
 
    [[nodiscard]] virtual eExceptionType exceptionType() const noexcept
    {
        return eExceptionType::Unknown;
    }
 
    [[nodiscard]] const char *what() const noexcept override
    {
        return m_msg.c_str();
    }
 
protected:
    std::string m_msg;
};
 
class InvalidArgument : public iv::exception::Exception
{
public:
    explicit InvalidArgument(const std::string_view msg) : iv::exception::Exception(msg)
    {
    }
 
    explicit InvalidArgument(std::string_view msg, std::string_view where)
        : iv::exception::Exception(fmt::format("{} in {}", msg, where))
    {
    }
 
    InvalidArgument(const std::string_view msg, const std::exception &e) : iv::exception::Exception(msg, e)
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::InvalidArgument;
    }
};
 
class UnknownPKFieldName final : public InvalidArgument
{
public:
    UnknownPKFieldName(std::string_view algo_name, std::string_view field_name)
        : InvalidArgument(fmt::format("Unknown field '{}' for algorithm {}", field_name, algo_name))
    {
    }
};
 
class InvalidKeyLength final : public InvalidArgument
{
public:
    InvalidKeyLength(std::string_view name, size_t length)
        : InvalidArgument(fmt::format("{} cannot accept a key of length {}", name, length))
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::InvalidKeyLength;
    }
};
 
class InvalidIVLength final : public InvalidArgument
{
public:
    InvalidIVLength(std::string_view mode, size_t badLength)
        : InvalidArgument(fmt::format("IV length {} is invalid for {}", badLength, mode))
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::InvalidNonceLength;
    }
};
 
class InvalidAlgorithmName final : public InvalidArgument
{
public:
    explicit InvalidAlgorithmName(std::string_view name)
        : InvalidArgument(fmt::format("Invalid algorithm name: '{}'", name))
    {
    }
};
 
class EncodingError final : public iv::exception::Exception
{
public:
    explicit EncodingError(const std::string_view name) : Exception("Encoding error:", name)
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::EncodingFailure;
    }
};
 
class DecodingError final : public iv::exception::Exception
{
public:
    explicit DecodingError(const std::string_view name) : Exception(name)
    {
    }
 
    DecodingError(std::string_view category, std::string_view err) : Exception(fmt::format("{}: {}", category, err))
    {
    }
 
    DecodingError(const std::string_view msg, const std::exception &e) : Exception(msg, e)
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::DecodingFailure;
    }
};
 
class InvalidState : public iv::exception::Exception
{
public:
    explicit InvalidState(const std::string_view err) : Exception(err)
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::InvalidObjectState;
    }
};
 
class PRNGUnseeded final : public InvalidState
{
public:
    explicit PRNGUnseeded(std::string_view algo) : InvalidState(fmt::format("PRNG {} not seeded", algo))
    {
    }
};
 
class KeyNotSet final : public InvalidState
{
public:
    explicit KeyNotSet(std::string_view algo) : InvalidState(fmt::format("Key not set in {}", algo))
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::KeyNotSet;
    }
};
 
class LookupError : public iv::exception::Exception
{
public:
    explicit LookupError(const std::string_view err) : Exception(err)
    {
    }
 
    LookupError(std::string_view type, std::string_view algo, std::string_view provider = "");
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::LookupError;
    }
};
 
class AlgorithmNotFound final : public LookupError
{
public:
    explicit AlgorithmNotFound(std::string_view name)
        : LookupError(fmt::format("Could not find any algorithm named '{}'", name))
    {
    }
};
 
class ProviderNotFound final : public LookupError
{
public:
    ProviderNotFound(std::string_view algo, std::string_view provider)
        : LookupError(fmt::format("Could not find provider '{}' for algorithm '{}'", provider, algo))
    {
    }
};
 
class InvalidAuthenticationTag final : public iv::exception::Exception
{
public:
    explicit InvalidAuthenticationTag(const std::string_view msg) : Exception("Invalid authentication tag:", msg)
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::InvalidTag;
    }
};
 
class StreamIOError final : public iv::exception::Exception
{
public:
    explicit StreamIOError(const std::string_view err) : Exception("I/O error:", err)
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::IoError;
    }
};
 
class InvalidFileIntegrity final : public iv::exception::Exception
{
public:
    explicit InvalidFileIntegrity(const std::string_view err) : Exception("Invalid file integrity: ", err)
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::InvalidFileIntegrity;
    }
};
 
class SystemError final : public iv::exception::Exception
{
public:
    explicit SystemError(const std::string_view msg) : Exception(msg), m_errorCode(0)
    {
    }
 
    SystemError(std::string_view msg, int errCode)
        : Exception(fmt::format("{} error code {}", msg, errCode)), m_errorCode(errCode)
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::SystemError;
    }
 
    [[nodiscard]] int64_t errorCode() const noexcept override
    {
        return m_errorCode;
    }
 
private:
    int64_t m_errorCode;
};
 
class InternalError final : public iv::exception::Exception
{
public:
    explicit InternalError(const std::string_view err) : Exception("Internal error:", err)
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::InternalError;
    }
};
 
class NotImplemented final : public iv::exception::Exception
{
public:
    NotImplemented(const std::string_view err, std::optional<std::string_view> file, std::optional<uint32_t> line)
        : Exception(fmt::format("Not implemented: {}", err))
    {
        if (file.has_value() && line.has_value())
        {
            m_msg += fmt::format(" at {}:{}", file.value(), line.value());
        }
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::NotImplemented;
    }
};
 
class IntegerOverflowDetected final : public iv::exception::Exception
{
public:
    IntegerOverflowDetected(std::string_view file, int line)
        : Exception(fmt::format("Integer overflow detected at {}:{}", file, line))
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::InternalError;
    }
};
 
class FolderNotFound final : public iv::exception::Exception
{
public:
    explicit FolderNotFound(std::string_view folder) : Exception(fmt::format("Folder {} not found", folder))
    {
    }
 
    FolderNotFound() : Exception("Folder not found")
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::FolderNotFound;
    }
};
 
class FileNotFound final : public iv::exception::Exception
{
public:
    explicit FileNotFound(std::string_view file) : Exception(fmt::format("File {} not found", file))
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::FileNotFound;
    }
};
 
class FileNameNotAvailable final : public iv::exception::Exception
{
public:
    explicit FileNameNotAvailable(std::string_view file) : Exception(fmt::format("File name not available: {}", file))
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::FileNameNotAvailable;
    }
};
 
class ImpossibleLabelingError final : public iv::exception::Exception
{
public:
    explicit ImpossibleLabelingError(const std::string &msg) : Exception(msg)
    {
    }
};
 
template<typename E, typename... Args>
inline void doThrowError(const char *file, int line, const char *func, Args... args)
{
    throw E(file, line, func, args...);
}
 
class MissingCase final : public iv::exception::Exception
{
public:
    explicit MissingCase(const std::string_view msg) : Exception(msg)
    {
        //TODO: ¿Mensaje? //("Missing case for value " + to_string(value) + " in function " + func + " at file " + file);
    }
 
    explicit MissingCase(std::string_view msg, std::string_view where) : Exception(fmt::format("{} in {}", msg, where))
    {
    }
 
    MissingCase(const std::string_view msg, const std::exception &e) : Exception(msg, e)
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::MissingCase;
    }
};
 
class LibZipError final : public iv::exception::Exception
{
public:
    explicit LibZipError(std::string_view msg) : Exception(fmt::format("LibZip error: {}", msg))
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::LibZipError;
    }
};
 
class OutOfBoundsMemoryAccess final : public iv::exception::Exception
{
public:
    explicit OutOfBoundsMemoryAccess(std::string_view msg)
        : Exception(fmt::format("Out of bounds memory access: {}", msg))
    {
    }
 
    [[nodiscard]] eExceptionType exceptionType() const noexcept override
    {
        return eExceptionType::OutOfBoundsMemoryAccess;
    }
};
}// namespace iv::exception
 
#endif//IV_SRC_CORE_EXCEPTION_HPP_