logger.hh

#pragma once
 
#include <bitset>
#include <cstdint>
#include <cstdio>
#include <functional>
#include <limits>
#include <sstream>
#include <stdexcept>
#ifndef _WIN32
#include <unistd.h>
#else
#define isatty(X) false
#endif
 
namespace CppClingo {
 
 
static constexpr size_t default_message_limit = 20;
 
enum class MessageCode : uint8_t {
    trace = 0,                    
    debug = 1,                    
    info = 2,                     
    info_operation_undefined = 3, 
    info_atom_undefined = 4,      
    info_file_included = 5,       
    info_global_variable = 6,     
    warn = 7,                     
    error = 8,                    
};
 
enum class LogLevel : uint8_t {
    trace = static_cast<uint8_t>(MessageCode::trace), 
    debug = static_cast<uint8_t>(MessageCode::debug), 
    info = static_cast<uint8_t>(MessageCode::info),   
    warn = static_cast<uint8_t>(MessageCode::warn),   
    error = static_cast<uint8_t>(MessageCode::error), 
};
 
class parse_error : public std::runtime_error {
  public:
    parse_error() : std::runtime_error{"parsing failed"} {}
};
 
class rewrite_error : public std::runtime_error {
  public:
    rewrite_error() : std::runtime_error{"rewriting failed"} {}
};
 
class Logger {
  public:
    using Printer = std::function<void(MessageCode, std::string_view)>;
    Logger(size_t limit = default_message_limit) : Logger{nullptr, limit} {}
    Logger(Printer p, size_t limit = default_message_limit)
        : p_(std::move(p)), limit_{limit}, cur_limit_(limit), color_{p_ == nullptr && isatty(fileno(stderr)) == 1} {}
 
    [[nodiscard]] auto check(MessageCode code) -> bool;
    void enable(MessageCode code, bool enable);
    [[nodiscard]] auto enabled(MessageCode code) const -> bool;
    void print(MessageCode code, std::string_view msg);
    void set_level(LogLevel level);
    void set_limit(size_t limit);
    [[nodiscard]] auto message_prefix(MessageCode code) const -> std::string_view;
    void reset();
    void enable_color(bool color) { color_ = color; };
 
  private:
    Printer p_;
    LogLevel level_ = LogLevel::info;
    size_t limit_;
    size_t cur_limit_;
    std::bitset<static_cast<int>(MessageCode::error) + 1> disabled_;
    bool color_;
};
 
class Report {
  public:
    Report(Logger &p, MessageCode code) : log_(p), code_(code) { out_ << log_.message_prefix(code) << ": "; }
    template <class Loc> Report(Logger &p, MessageCode code, Loc const &loc) : log_(p), code_(code) {
        out_ << loc << ": " << log_.message_prefix(code) << ": ";
    }
    ~Report() noexcept(false) { log_.print(code_, out_.view()); }
    [[nodiscard]] auto out() -> std::ostringstream & { return out_; }
 
  private:
    std::ostringstream out_;
    Logger &log_;
    MessageCode code_;
};
 
inline auto Logger::check(MessageCode code) -> bool {
    // ignore the message
    if (static_cast<uint8_t>(code) < static_cast<uint8_t>(level_) || disabled_[static_cast<int>(code)]) {
        return false;
    }
    // report trace and debug messages without reducing the limit
    if (code < MessageCode::info) {
        return true;
    }
    // report the message
    if (cur_limit_ > 0) {
        if (cur_limit_ != std::numeric_limits<size_t>::max()) {
            --cur_limit_;
        }
        return true;
    }
    // ignore the message due to limit
    return false;
}
 
inline auto Logger::enabled(MessageCode code) const -> bool {
    if (code >= MessageCode::error) {
        return true;
    }
    if (code < static_cast<MessageCode>(level_) || disabled_[static_cast<int>(code)]) {
        return false;
    }
    return code < MessageCode::info || cur_limit_ > 0;
}
 
inline void Logger::enable(MessageCode code, bool enabled) {
    disabled_[static_cast<int>(code)] = !enabled;
}
 
inline void Logger::set_level(LogLevel level) {
    level_ = level;
}
 
inline void Logger::set_limit(size_t limit) {
    cur_limit_ = limit;
}
 
inline void Logger::print(MessageCode code, std::string_view msg) {
    if (p_ != nullptr) {
        try {
            p_(code, msg);
        } catch (std::exception const &e) {
            fprintf(stderr, "logging failed: %s\n", e.what());
            fflush(stderr);
        }
    } else {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg)
        fprintf(stderr, "%.*s\n", static_cast<int>(msg.size()), msg.data());
        fflush(stderr);
    }
}
 
inline void Logger::reset() {
    cur_limit_ = limit_;
}
 
inline auto Logger::message_prefix(MessageCode code) const -> std::string_view {
    auto const *prefix = color_ ? "\033[31m"
                                  "error"
                                  "\033[0m"
                                : "error";
    if (code < MessageCode::debug) {
        prefix = color_ ? "\033[32m"
                          "trace"
                          "\033[0m"
                        : "trace";
    } else if (code < MessageCode::info) {
        prefix = color_ ? "\033[34m"
                          "debug"
                          "\033[0m"
                        : "debug";
    } else if (code < MessageCode::warn) {
        prefix = color_ ? "\033[35m"
                          "info"
                          "\033[0m"
                        : "info";
    } else if (code < MessageCode::error) {
        prefix = color_ ? "\033[33m"
                          "warning"
                          "\033[0m"
                        : "warning";
    }
    return prefix;
}
 
// NOLINTBEGIN(cppcoreguidelines-macro-usage)
 
#define CLINGO_REPORT(p, id)                                                                                           \
    if ((p).check(::CppClingo::MessageCode::id))                                                                       \
    CppClingo::Report(p, ::CppClingo::MessageCode::id).out()
 
#define CLINGO_REPORT_LOC(p, id, loc)                                                                                  \
    if ((p).check(::CppClingo::MessageCode::id))                                                                       \
    CppClingo::Report(p, ::CppClingo::MessageCode::id, loc).out()
 
#define CLINGO_REPORT_STR(p, id, msg)                                                                                  \
    if ((p).check(::CppClingo::MessageCode::id)) {                                                                     \
        (p).print(::CppClingo::MessageCode::id, msg);                                                                  \
    }
 
// NOLINTEND(cppcoreguidelines-macro-usage)
 
 
} // namespace CppClingo