Logger.h

Go to the documentation of this file.

#pragma once
 
 
#include "common/Globals.h"
#include "io/Path.h"
#include "objects/containers/Array.h"
#include "objects/wrappers/AutoPtr.h"
#include "objects/wrappers/Flags.h"
#include "system/Timer.h"
#include <iomanip>
 
NAMESPACE_SPH_BEGIN
 
class ILogger : public Polymorphic, public Noncopyable {
private:
    Size precision = PRECISION;
    bool scientific = true;
 
public:
    virtual void writeString(const std::string& s) = 0;
 
    template <typename... TArgs>
    void write(TArgs&&... args) {
        std::stringstream ss;
        writeImpl(ss, std::forward<TArgs>(args)...);
        ss << std::endl;
        this->writeString(ss.str());
    }
 
    void setPrecision(const Size newPrecision) {
        precision = newPrecision;
    }
 
    void setScientific(const bool newScientific) {
        scientific = newScientific;
    }
 
private:
    template <typename T0, typename... TArgs>
    void writeImpl(std::stringstream& ss, T0&& first, TArgs&&... rest) {
        ss << std::setprecision(precision);
        if (scientific) {
            ss << std::scientific;
        }
        ss << first;
        writeImpl(ss, std::forward<TArgs>(rest)...);
    }
    void writeImpl(std::stringstream& UNUSED(ss)) {}
};
 
 
struct Console {
    enum class Foreground {
        BLACK = 30,
        RED = 31,
        GREEN = 32,
        YELLOW = 33,
        BLUE = 34,
        MAGENTA = 35,
        CYAN = 36,
        LIGHT_GRAY = 37,
        DARK_GRAY = 90,
        LIGHT_RED = 91,
        LIGHT_GREEN = 92,
        LIGHT_YELLOW = 93,
        LIGHT_BLUE = 94,
        LIGHT_MAGENTA = 95,
        LIGHT_CYAN = 96,
        WHITE = 97,
        DEFAULT = 39,
        UNCHANGED = 0,
    } fg = Foreground::UNCHANGED;
 
    enum class Background {
        RED = 41,
        GREEN = 42,
        BLUE = 44,
        DEFAULT = 49,
        UNCHANGED = 0
    } bg = Background::UNCHANGED;
 
    enum class Series {
        NORMAL = 0,
        BOLD = 1,
    } series = Series::NORMAL;
 
    Console() = default;
 
    Console(const Foreground fg)
        : fg(fg) {}
 
    Console(const Background bg)
        : bg(bg) {}
 
    Console(const Series series)
        : series(series) {}
 
    friend std::ostream& operator<<(std::ostream& stream, const Console& mod) {
        if (mod.bg != Background::UNCHANGED) {
            stream << "\033[" << int(mod.bg) << "m";
        }
        if (mod.fg != Foreground::UNCHANGED) {
            stream << "\033[" << int(mod.fg) << "m";
        }
        stream << "\e[" << int(mod.series) << "m";
        return stream;
    }
};
 
struct ScopedConsole {
    ScopedConsole(const Console console);
    ~ScopedConsole();
};
 
 
class StdOutLogger : public ILogger {
public:
    virtual void writeString(const std::string& s) override;
};
 
 
class StringLogger : public ILogger {
private:
    std::stringstream ss;
 
public:
    virtual void writeString(const std::string& s) override;
 
    void clean();
 
    std::string toString() const;
};
 
class FileLogger : public ILogger {
public:
    enum class Options {
        KEEP_OPENED = 0,
 
        OPEN_WHEN_WRITING = 1 << 0,
 
        APPEND = 1 << 1,
 
        ADD_TIMESTAMP = 1 << 2,
    };
 
private:
    AutoPtr<std::ofstream> stream;
    Path path;
    Flags<Options> flags;
 
public:
    FileLogger(const Path& path, const Flags<Options> flags = EMPTY_FLAGS);
 
    ~FileLogger();
 
    virtual void writeString(const std::string& s) override;
};
 
class MultiLogger : public ILogger {
private:
    Array<AutoPtr<ILogger>> loggers;
 
public:
    Size getLoggerCnt() const {
        return loggers.size();
    }
 
    void add(AutoPtr<ILogger>&& logger) {
        loggers.push(std::move(logger));
    }
 
    virtual void writeString(const std::string& s) override {
        for (auto& l : loggers) {
            l->writeString(s);
        }
    }
};
 
class NullLogger : public ILogger {
public:
    virtual void writeString(const std::string& UNUSED(s)) override {}
};
 
class VerboseLogGuard : public Noncopyable {
private:
    Timer timer;
 
public:
    VerboseLogGuard(const std::string& functionName);
 
    ~VerboseLogGuard();
};
 
void setVerboseLogger(AutoPtr<ILogger>&& logger);
 
#define VERBOSE_LOG VerboseLogGuard __verboseLogGuard(__PRETTY_FUNCTION__);
 
NAMESPACE_SPH_END