exceptions.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <exception>
#include <string>
#include <utility>
 
#include "log_admindb_arpwatch_exporter.h"
#include <log/logger.h>
#include <log/macros.h>
 
class InitFailure : public std::exception
{
public:
    explicit InitFailure(std::string message) : message(std::move(message))
    {}
 
    InitFailure(const InitFailure&) = default;
    InitFailure& operator=(const InitFailure&) = default;
    InitFailure(InitFailure&&) = default;
    InitFailure& operator=(InitFailure&&) = default;
    ~InitFailure() override = default;
 
    [[nodiscard]] const char* what() const noexcept override
    {
        return message.c_str();
    }
 
    virtual void log(isc::log::Logger& logger) const
    {
        LOG_ERROR(logger, arpwatch::INIT_FAILED).arg(message);
    }
 
protected:
    std::string message; // NOLINT(*-non-private-member-variables-in-classes)
};
 
class InvalidConfig : public InitFailure
{
public:
    InvalidConfig(const std::string& key, const std::string& expected, const std::string& actual)
        : InitFailure("Key: " + key + ", Expected: " + expected + ", Actual: " + actual)
        , key(key)
        , expected(expected)
        , actual(actual)
    {}
 
protected:
    explicit InvalidConfig(const std::string& message) : InitFailure(message)
    {}
 
public:
    void log(isc::log::Logger& logger) const override
    {
        LOG_ERROR(logger, arpwatch::INVALID_PARAMETER).arg(key).arg(expected).arg(actual);
    }
 
protected:
    // NOLINTBEGIN(*-non-private-member-variables-in-classes)
    std::string key{};
    std::string expected{};
    std::string actual{};
    // NOLINTEND(*-non-private-member-variables-in-classes)
};
 
class InvalidConfigMissingElement : public InvalidConfig
{
public:
    explicit InvalidConfigMissingElement(const std::string& key)
        : InvalidConfig("Key: " + key + " undefined, but required")
    {
        this->key = key;
    }
 
    void log(isc::log::Logger& logger) const override
    {
        LOG_ERROR(logger, arpwatch::UNDEFINED_PARAMETER).arg(key);
    }
};
 
class HiredisInitFailure : public InitFailure
{
public:
    explicit HiredisInitFailure(const std::string& msg) : InitFailure(msg)
    {}
 
    void log(isc::log::Logger& logger) const override
    {
        LOG_ERROR(logger, arpwatch::HIREDIS_INIT_FAILED).arg(message);
    }
};