magic_exception.hpp

Go to the documentation of this file.

/* SPDX-FileCopyrightText: Copyright (c) 2022-2025 Oğuz Toraman <oguz.toraman@tutanota.com> */
/* SPDX-License-Identifier: LGPL-3.0-only */
 
#ifndef MAGIC_EXCEPTION_HPP
#define MAGIC_EXCEPTION_HPP
 
#include <format>
#include <stdexcept>
#include <string>
 
namespace recognition {
class magic_exception : public std::runtime_error {
public:
    using std::runtime_error::runtime_error;

    magic_exception(
        const std::string& function,
        const std::string& error_message
    )
      : std::runtime_error{
            error_message.empty()
                ? function + " failed."
                : function + " failed with " + error_message + "."
        }
    { }
};

class null_tracker final : public magic_exception {
public:
    null_tracker()
      : magic_exception{"shared progress_tracker is null."}
    { }
};

class empty_path final : public magic_exception {
public:
    empty_path()
      : magic_exception{"path is empty."}
    { }
};

class path_is_not_regular_file final : public magic_exception {
public:
    explicit path_is_not_regular_file(const std::string& path)
      : magic_exception{std::format("'{}' is not a regular file.", path)}
    { }
};

class path_is_not_directory final : public magic_exception {
public:
    explicit path_is_not_directory(const std::string& path)
      : magic_exception{std::format("'{}' is not a directory.", path)}
    { }
};

class path_does_not_exist final : public magic_exception {
public:
    explicit path_does_not_exist(const std::string& path)
      : magic_exception{std::format("'{}' does not exist.", path)}
    { }
};

class filesystem_error final : public magic_exception {
public:
    filesystem_error(const std::string& path, const std::string& error_message)
      : magic_exception{std::format("'{}': {}.", path, error_message)}
    { }
};

class magic_is_closed final : public magic_exception {
public:
    magic_is_closed()
      : magic_exception{"magic is closed."}
    { }
};

class magic_open_error final : public magic_exception {
public:
    explicit magic_open_error(const std::string& error_message)
      : magic_exception{"magic_open", error_message}
    { }
};

class magic_load_database_file_error final : public magic_exception {
public:
    magic_load_database_file_error(
        const std::string& error_message,
        const std::string& database_file_path
    )
      : magic_exception{
            std::format("magic_load_database_file({})", database_file_path),
            error_message
        }
    { }
};

class magic_database_not_loaded final : public magic_exception {
public:
    magic_database_not_loaded()
      : magic_exception{"magic database is not loaded."}
    { }
};

class magic_identify_file_error final : public magic_exception {
public:
    magic_identify_file_error(
        const std::string& error_message,
        const std::string& file_path
    )
      : magic_exception{
            std::format("magic_identify_file({})", file_path),
            error_message
        }
    { }
};

class magic_set_flags_error final : public magic_exception {
public:
    magic_set_flags_error(
        const std::string& error_message,
        const std::string& flag_names
    )
      : magic_exception{
            std::format("magic_set_flags({})", flag_names),
            error_message
        }
    { }
};

class magic_set_parameter_error final : public magic_exception {
public:
    magic_set_parameter_error(
        const std::string& error_message,
        const std::string& parameter_name,
        std::size_t        value
    )
      : magic_exception{
            std::format("magic_set_parameter({}, {})", parameter_name, value),
            error_message
        }
    { }
};
} /* namespace recognition */
 
#endif /* MAGIC_EXCEPTION_HPP */