Lesson_03/Task_3/Task_3.cpp - master - AirLexa/07

Lesson_03/Task_3/Task_3.cpp
137 строк4 KB
AirLexa
урок 3
25 июн 2026, 13:54
25 июн 2026, 13:54dd3ebc1
#include <iostream>
#include <fstream>

// Типы сообщений
enum class LogType {
    Warning,
    Error,
    FatalError,
    Unknown
};

// Сообщение лога
class LogMessage {
public:
    LogMessage(LogType type, const std::string& message)
        : m_type(type), m_message(message) {
    }

    LogType type() const { return m_type; }
    const std::string& message() const { return m_message; }

private:
    LogType m_type;
    std::string m_message;
};

// Базовый обработчик
class LogHandler {
public:
    virtual ~LogHandler() = default;

    // Установить следующий обработчик в цепочке
    void setNext(LogHandler* next) {
        m_next = next;
    }

    // Обработать сообщение
    virtual void handle(const LogMessage& msg) = 0;

protected:
    // Передать следующему обработчику
    void passToNext(const LogMessage& msg) const {
        if (m_next) m_next->handle(msg);
    }

private:
    LogHandler* m_next = nullptr;
};

// Обработчик фатальной ошибки - выбрасывает исключение
class FatalErrorHandler : public LogHandler {
public:
    void handle(const LogMessage& msg) override {
        if (msg.type() == LogType::FatalError)
            throw std::runtime_error(msg.message());
        passToNext(msg);
    }
};

// Обработчик обычной ошибки - записывает в файл
class ErrorHandler : public LogHandler {
public:
    explicit ErrorHandler(const std::string& filePath)
        : m_filePath(filePath) {}

    void handle(const LogMessage& msg) override {
        if (msg.type() == LogType::Error) {
            std::ofstream file(m_filePath, std::ios::app);
            if (!file.is_open())
                throw std::runtime_error("ErrorHandler: cannot open file " + m_filePath);
            file << "[ERROR] " << msg.message() << "\n";
        }
        else passToNext(msg);
    }

private:
    std::string m_filePath;
};

// Обработчик предупреждения - выводит в консоль
class WarningHandler : public LogHandler {
public:
    void handle(const LogMessage& msg) override {
        if (msg.type() == LogType::Warning)
            std::cout << "[WARNING] " << msg.message() << std::endl;
        else passToNext(msg);
    }
};

// Обработчик неизвестного сообщения - выбрасывает исключение
class UnknownHandler : public LogHandler {
public:
    void handle(const LogMessage& msg) override {
        if (msg.type() == LogType::Unknown) {
            throw std::runtime_error("Unhandled message: " + msg.message());
        }
        passToNext(msg);
    }
};


int main() {
    
    FatalErrorHandler fatalHandler;
    ErrorHandler errorHandler("task3_errors.txt");
    WarningHandler warningHandler;
    UnknownHandler unknownHandler;

    fatalHandler.setNext(&errorHandler);
    errorHandler.setNext(&warningHandler);
    warningHandler.setNext(&unknownHandler);

    LogMessage warn(LogType::Warning, "CPU usage is high");
    fatalHandler.handle(warn);

    LogMessage err(LogType::Error, "Failed to write config");
    fatalHandler.handle(err);

    try {
        LogMessage fatal(LogType::FatalError, "Kernel panic!");
        fatalHandler.handle(fatal);
    }
    catch (const std::exception& e) {
        std::cout << "[CAUGHT FATAL EXCEPTION] " << e.what() << std::endl;
    }
    try {
        LogMessage unknown(LogType::Unknown, "???");
        fatalHandler.handle(unknown);
    }
    catch (const std::exception& e) {
        std::cout << "[CAUGHT UNKNOWN EXCEPTION] " << e.what() << std::endl;
    }

    std::cout << std::endl;

    return 0;
}