1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
/** ---------------------------------------------------------------------------
* -*- c++ -*-
* @file: logger.h
*
* Copyright (c) 2017 Yann Herklotz Grave <ymherklotz@gmail.com>
* MIT License, see LICENSE file for more details.
* ----------------------------------------------------------------------------
*/
#pragma once
#include "../util/active.h"
#include <memory>
#include <sstream>
#include <string>
#include <vector>
namespace yage
{
class Logger;
/**
* Different log levels that can be assigned to each message sent to the Logger.
* The logger then outputs the message if it is above the minimum log level, or
* does not process it.
*/
enum class LogLevel {
/// Lowest log level. This is used by the game engine to output debugging
/// information but is turned off in the logger by default.
DEBUG,
/// Information message.
INFO,
/// Warning message.
WARNING,
#ifdef _WIN32
#ifdef ERROR
#define YAGE_ERROR_TMP ERROR
#undef ERROR
#endif
#endif
/// Error message.
ERROR,
#ifdef _WIN32
#ifdef YAGE_ERROR_TMP
#define ERROR YAGE_ERROR_TMP
#undef YAGE_ERROR_TMP
#endif
#endif
/// Fatal message that should be output when the game
/// crashes.
FATAL,
};
class LogMessage
{
public:
~LogMessage();
LogMessage(const LogMessage &msg) = delete;
LogMessage &operator=(const LogMessage &msg) = delete;
LogMessage &operator=(LogMessage &&msg) = delete;
template <typename T>
LogMessage &operator<<(const T &value);
LogMessage &operator<<(std::ostream &(*fn)(std::ostream &os));
struct Meta {
LogLevel level;
std::string fileName;
int line;
};
private:
friend class Logger;
std::ostringstream buffer_;
Logger *owner_;
LogMessage::Meta meta_;
LogMessage(Logger *owner, LogLevel level, const std::string &file_name,
int line_num);
LogMessage(LogMessage &&msg);
};
class LogSink
{
public:
template <typename T>
LogSink(T impl);
LogSink(const LogSink &sink);
LogSink(LogSink &&sink);
LogSink &operator=(const LogSink &sink);
LogSink &operator=(LogSink &&sink);
bool operator==(const LogSink &sink);
void write(const LogMessage::Meta &meta, const std::string &msg) const;
private:
struct Concept {
virtual ~Concept() = default;
virtual Concept *clone() const = 0;
virtual void write(const LogMessage::Meta &meta,
const std::string &msg) const = 0;
};
template <typename T>
struct Model : Concept {
Model(T impl_i);
virtual Concept *clone() const override;
virtual void write(const LogMessage::Meta &meta,
const std::string &msg) const override;
T impl;
};
std::unique_ptr<Concept> wrapper_;
};
class Logger
{
public:
Logger();
explicit Logger(const std::string &file_path);
explicit Logger(LogLevel min_level);
Logger(LogLevel min_level, const std::string &file_path);
LogMessage operator()(LogLevel level = LogLevel::INFO,
const std::string &fileName = "", int lineNum = -1);
void flush(const LogMessage *msg);
void add(const LogSink &sink);
void remove(const LogSink &sink);
void clear();
static Logger &instance();
// setter for the level
void setLevel(LogLevel min_level);
private:
std::vector<LogSink> sinks_;
std::unique_ptr<Active> active_;
LogLevel min_level_;
};
LogSink makeConsoleSink();
LogSink makeFileSink(const std::string &filename);
LogSink makeFileSink(std::string &&filename);
/* -----------------------------------------------------------------------------
* Template Implementation
* -----------------------------------------------------------------------------
*/
template <typename T>
LogSink::LogSink(T impl) : wrapper_(new Model<T>(std::move(impl)))
{
}
template <typename T>
LogSink::Model<T>::Model(T impl_i) : impl(impl_i)
{
}
template <typename T>
LogSink::Concept *LogSink::Model<T>::clone() const
{
return new Model<T>(impl);
}
template <typename T>
void LogSink::Model<T>::write(const LogMessage::Meta &meta,
const std::string &msg) const
{
impl(meta, msg);
}
template <typename T>
LogMessage &LogMessage::operator<<(const T &value)
{
buffer_ << value;
return *this;
}
} // namespace yage
#define yLogger (yage::Logger::instance())
#define yLogDebug \
(yage::Logger::instance()(yage::LogLevel::DEBUG, __FILE__, __LINE__))
#define yLogInfo \
(yage::Logger::instance()(yage::LogLevel::INFO, __FILE__, __LINE__))
#define yLogWarning \
(yage::Logger::instance()(yage::LogLevel::WARNING, __FILE__, __LINE__))
#define yLogError \
(yage::Logger::instance()(yage::LogLevel::ERROR, __FILE__, __LINE__))
#define yLogFatal \
(yage::Logger::instance()(yage::LogLevel::FATAL, __FILE__, __LINE__))
|
