Log/Log.h

#pragma once

#include <functional>  // std::function
#include <sstream>  // std::stringstream (buffer for log entries)
#include <string>
#include <vector>

#ifndef LOG_USEMUTEX
#define LOG_USEMUTEX 0
#endif

namespace Log {
enum class Level { off = 0, fatal, error, warn, note, info, debug, trace };

// set up the logger with a ConsoleOutput
void init();
// close all output streams
void stop();

void addLogfile(const std::string& filename, Level max, bool truncate = false);
void addLogfile(const std::string& filename, Level min, Level max, bool truncate = false);

void setConsoleLogLevel(Level lvl);
void setColoredOutput(bool enabled);

// Log entry that can be formed with various mixed data types
// by concatenation with the << operator
// Inspired from https://stackoverflow.com/a/8337882
class Entry {
private:
	std::stringstream ss;
	const Level lvl;

	void addMetadataHeader();

public:
	explicit Entry(Level lvl);
	Entry(const Entry&) = delete;
	Entry& operator=(const Entry&) = delete;
	Entry(Entry&&) = default;
	Entry& operator=(Entry&&) = default;
	~Entry();

	Level getLevel() const {
		return lvl;
	}

	using MetaFunction = std::function<std::ostream&(std::ostream&, const Entry&)>;

	template <typename T> Entry& operator<<(const T& msg) {
		ss << msg;
		return *this;
	}
};

extern std::vector<Entry::MetaFunction> entryMetaFunctions;

std::ostream& defaultEntryMetaTime(std::ostream&, const Entry&);
std::ostream& defaultEntryMetaLevel(std::ostream&, const Entry&);

class LeveledSink {
private:
	Level level;

public:
	explicit LeveledSink(Level level) noexcept : level{level} {};

	template <typename T> Entry operator<<(const T& msg) const {
		Entry entry{level};
		entry << msg;
		return entry;
	}
};

// LeveledSinks
extern const LeveledSink fatal;
extern const LeveledSink error;
extern const LeveledSink warn;
extern const LeveledSink note;
extern const LeveledSink info;
extern const LeveledSink debug;
extern const LeveledSink trace;

} // namespace Log