magic_exception.hpp

Go to the documentation of this file.

/* SPDX-FileCopyrightText: Copyright (c) 2022-2026 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 MagicException : public std::runtime_error {
public:
    using std::runtime_error::runtime_error;

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

class NullTracker final : public MagicException {
public:
    NullTracker()
      : MagicException{"shared ProgressTracker is null."}
    { }
};

class EmptyPath final : public MagicException {
public:
    EmptyPath()
      : MagicException{"path is empty."}
    { }
};

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

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

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

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

class MagicIsClosed final : public MagicException {
public:
    MagicIsClosed()
      : MagicException{"Magic is closed."}
    { }
};

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

class MagicLoadDatabaseFileError final : public MagicException {
public:
    MagicLoadDatabaseFileError(
        const std::string& error_message,
        const std::string& database_file_path
    )
      : MagicException{
            std::format("Magic::LoadDatabaseFile({})", database_file_path),
            error_message
        }
    { }
};

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

class MagicIdentifyFileError final : public MagicException {
public:
    MagicIdentifyFileError(
        const std::string& error_message,
        const std::string& file_path
    )
      : MagicException{
            std::format("Magic::IdentifyFile({})", file_path),
            error_message
        }
    { }
};

class MagicSetFlagsError final : public MagicException {
public:
    MagicSetFlagsError(
        const std::string& error_message,
        const std::string& flag_names
    )
      : MagicException{
            std::format("Magic::SetFlags({})", flag_names),
            error_message
        }
    { }
};

class MagicSetParameterError final : public MagicException {
public:
    MagicSetParameterError(
        const std::string& error_message,
        const std::string& parameter_name,
        std::size_t        value
    )
      : MagicException{
            std::format("Magic::SetParameter({}, {})", parameter_name, value),
            error_message
        }
    { }
};

} /* namespace Recognition */
 
#endif /* MAGIC_EXCEPTION_HPP */