log.h

Go to the documentation of this file.

#pragma once
#include <functional>
#include <optional>
#include <vector>
#include <chrono>
#include <ostream>
#include <string>
#include "field.h"
#ifdef WEBCFACE_MESON
#include "webcface-config.h"
#else
#include "webcface/common/webcface-config.h"
#endif
 
WEBCFACE_NS_BEGIN
namespace message {
struct LogLine;
}
 
enum class LogLevel : int {
    trace = 0,
    debug = 1,
    info = 2,
    warn = 3,
    warning = 3,
    error = 4,
    critical = 5,
};
using level = LogLevel;
 
inline std::ostream &operator<<(std::ostream &os, LogLevel level) {
    switch (level) {
    case LogLevel::trace:
        return os << "trace";
    case LogLevel::debug:
        return os << "debug";
    case LogLevel::info:
        return os << "info";
    case LogLevel::warn:
        return os << "warn";
    case LogLevel::error:
        return os << "error";
    case LogLevel::critical:
        return os << "critical";
    default:
        return os << std::to_string(static_cast<int>(level));
    }
}
 
struct WEBCFACE_DLL LogLineData {
    int level_ = 0;
    std::chrono::system_clock::time_point time_;
    SharedString message_;
 
    LogLineData() = default;
    LogLineData(int level, std::chrono::system_clock::time_point time,
                const SharedString &message);
 
    LogLineData(const message::LogLine &m);
    message::LogLine toMessage() const;
};
 
class LogLine : private LogLineData {
  public:
    LogLine(const LogLineData &ll) : LogLineData(ll) {}
    LogLevel level() const { return static_cast<LogLevel>(level_); }
    std::chrono::system_clock::time_point time() const { return time_; }
    StringView message() const { return message_.decodeShare(); };
};
class LogLineW : private LogLineData {
  public:
    LogLineW(const LogLineData &ll) : LogLineData(ll) {}
    LogLevel level() const { return static_cast<LogLevel>(level_); }
    std::chrono::system_clock::time_point time() const { return time_; }
    WStringView message() const { return message_.decodeShareW(); };
};
 
class WEBCFACE_DLL Log : protected Field {
  public:
    Log() = default;
    Log(const Field &base);
    Log(const Field &base, const SharedString &field)
        : Log(Field{base, field}) {}
 
    using Field::lastName;
    using Field::lastNameW;
    using Field::member;
    using Field::name;
    using Field::nameW;
    Log child(StringInitializer field) const {
        return this->Field::child(static_cast<SharedString &>(field));
    }
    Log operator[](StringInitializer field) const {
        return child(std::move(field));
    }
    Log parent() const { return this->Field::parent(); }
 
 
    static void WEBCFACE_CALL keepLines(int n);
 
    const Log &
    onChange(std::function<void WEBCFACE_CALL_FP(Log)> callback) const;
    template <typename F, typename std::enable_if_t<std::is_invocable_v<F>,
                                                    std::nullptr_t> = nullptr>
    const Log &onChange(F callback) const {
        return onChange(
            [callback = std::move(callback)](const auto &) { callback(); });
    }
 
    const Log &request() const;
    std::optional<std::vector<LogLine>> tryGet() const;
    std::optional<std::vector<LogLineW>> tryGetW() const;
    std::vector<LogLine> get() const {
        return tryGet().value_or(std::vector<LogLine>{});
    }
    std::vector<LogLineW> getW() const {
        return tryGetW().value_or(std::vector<LogLineW>{});
    }
 
    bool exists() const;
    const Log &clear() const;
 
  private:
    const Log &append(LogLineData &&ll) const;
 
  public:
    const Log &append(LogLevel level, StringInitializer message) const {
        return append({static_cast<int>(level),
                       std::chrono::system_clock::now(),
                       static_cast<SharedString &>(message)});
    }
    const Log &append(int level, StringInitializer message) const {
        return append({level, std::chrono::system_clock::now(),
                       static_cast<SharedString &>(message)});
    }
    const Log &append(LogLevel level,
                      std::chrono::system_clock::time_point time,
                      StringInitializer message) const {
        return append({static_cast<int>(level), time,
                       static_cast<SharedString &>(message)});
    }
    const Log &append(int level, std::chrono::system_clock::time_point time,
                      StringInitializer message) const {
        return append({level, time, static_cast<SharedString &>(message)});
    }
 
    template <typename T, typename std::enable_if_t<std::is_same_v<T, Log>,
                                                    std::nullptr_t> = nullptr>
    bool operator==(const T &other) const {
        return static_cast<Field>(*this) == static_cast<Field>(other);
    }
    template <typename T, typename std::enable_if_t<std::is_same_v<T, Log>,
                                                    std::nullptr_t> = nullptr>
    bool operator!=(const T &other) const {
        return static_cast<Field>(*this) != static_cast<Field>(other);
    }
};
WEBCFACE_NS_END