← Back to branch summary

~dobey/unity-api/add-simple-logger

« back to all changes in this revision

Viewing changes to include/unity/util/Logger.h

  • Committer: Rodney Dawes
  • Date: 2017-04-03 21:10:23 UTC
  • Revision ID: rodney.dawes@canonical.com-20170403211023-2dttuxcug3l3t1b1
Move some code into C++ and greatly simplify the implementation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/unity/util/Logger.h
18
18
 
19
19
#pragma once
20
20
 
21
 
#include <glib.h>
22
 
 
23
21
#include <sstream>
24
 
#include <string>
25
22
 
26
23
namespace unity
27
24
{
29
26
namespace util
30
27
{
31
28
 
32
 
    class Logger
 
29
    class Logger: public std::ostringstream
33
30
    {
34
31
    public:
35
32
        enum class Level {
36
 
            UNKNOWN = -1,
37
 
            DEBUG,
 
33
            DEBUG = 0,
 
34
            INFO,
 
35
            MESSAGE,
38
36
            WARNING,
39
37
            CRITICAL,
40
 
            ERROR
 
38
            ERROR,
41
39
        };
42
40
 
43
 
        Logger(Level level)
44
 
            : _level(level),
45
 
            _space(true),
46
 
            _stream("") {
47
 
        }
48
 
 
49
 
        ~Logger() {
50
 
            // Strip the ending space char if it exists
51
 
            auto result = _stream.str();
52
 
            if (result.rfind(' ') == std::string::npos) {
53
 
                result.pop_back();
54
 
            }
55
 
 
56
 
            // Write the log
57
 
            log(result);
58
 
        }
59
 
 
60
 
        static inline const char* log_level_string(Level level)
61
 
        {
62
 
            switch (level) {
63
 
            case Level::DEBUG:
64
 
                return "DEBUG";
65
 
                break;
66
 
            case Level::WARNING:
67
 
                return "WARNING";
68
 
                break;
69
 
            case Level::CRITICAL:
70
 
                return "CRITICAL";
71
 
                break;
72
 
            case Level::ERROR:
73
 
                return "ERROR";
74
 
                break;
75
 
            default:
76
 
                return "UNKNOWN";
77
 
            }
78
 
        }
79
 
 
80
 
        inline void log(const std::string& message)
81
 
        {
82
 
            switch (_level) {
83
 
            case Level::DEBUG:
84
 
                g_debug("%s", message.c_str());
85
 
                break;
86
 
            case Level::WARNING:
87
 
                g_warning("%s", message.c_str());
88
 
                break;
89
 
            case Level::CRITICAL:
90
 
                g_critical("%s", message.c_str());
91
 
                break;
92
 
            case Level::ERROR:
93
 
                g_error("%s", message.c_str());
94
 
                break;
95
 
            default:
96
 
                g_message("%s", message.c_str());
97
 
                break;
98
 
            }
99
 
        }
100
 
 
101
 
 
102
 
        inline Logger& no_space() { return *this; }
103
 
        inline Logger& maybe_space() {
104
 
            if (_space) {
105
 
                _stream << ' ';
106
 
            }
107
 
            return *this;
108
 
        }
109
 
 
110
 
        inline Logger& operator<<(Level l) {
111
 
            _stream << log_level_string(l);
112
 
 
113
 
            return maybe_space();
114
 
        }
115
 
 
116
 
        inline Logger& operator<<(bool b) {
117
 
            _stream << (b ? "true" : "false");
118
 
 
119
 
            return maybe_space();
120
 
        }
121
 
 
122
 
        inline Logger& operator<<(char c) {
123
 
            _stream << c;
124
 
 
125
 
            return maybe_space();
126
 
        }
127
 
 
128
 
        inline Logger& operator<<(const char *s) {
129
 
            _stream << s;
130
 
 
131
 
            return maybe_space();
132
 
        }
133
 
 
134
 
        inline Logger& operator<<(const std::string& s) {
135
 
            _stream << s;
136
 
 
137
 
            return maybe_space();
138
 
        }
139
 
 
140
 
        inline Logger& operator<<(const void *p) {
141
 
            _stream << ((p == NULL) ? "(null)" : p);
142
 
 
143
 
            return maybe_space();
144
 
        }
145
 
 
146
 
        inline Logger& operator<<(std::nullptr_t) {
147
 
            _stream << "(nullptr)";
148
 
 
149
 
            return maybe_space();
150
 
        }
151
 
 
152
 
        inline Logger& operator<<(int t) {
153
 
            _stream << t;
154
 
            return maybe_space();
155
 
        }
156
 
 
157
 
        inline Logger& operator<<(long t) {
158
 
            _stream << t;
159
 
            return maybe_space();
160
 
        }
161
 
 
162
 
        inline Logger& operator<<(long long t) {
163
 
            _stream << t;
164
 
            return maybe_space();
165
 
        }
166
 
 
167
 
        inline Logger& operator<<(unsigned int t) {
168
 
            _stream << t;
169
 
            return maybe_space();
170
 
        }
171
 
 
172
 
        inline Logger& operator<<(unsigned long t) {
173
 
            _stream << t;
174
 
            return maybe_space();
175
 
        }
176
 
 
177
 
        inline Logger& operator<<(unsigned long long t) {
178
 
            _stream << t;
179
 
            return maybe_space();
180
 
        }
181
 
 
182
 
        inline Logger& operator<<(float f) {
183
 
            _stream << f;
184
 
            return maybe_space();
185
 
        }
186
 
 
187
 
        inline Logger& operator<<(double d) {
188
 
            _stream << d;
189
 
            return maybe_space();
190
 
        }
 
41
        Logger(Logger::Level level, const std::string& domain);
 
42
        Logger(Logger&& logger);
 
43
 
 
44
        virtual ~Logger();
191
45
 
192
46
    private:
193
47
        Level _level;
194
 
        bool _space;
195
 
        std::ostringstream _stream;
 
48
        std::string _domain;
196
49
    };
197
50
 
198
51
// These are the APIs to be used for logging.
199
 
#define debug() Logger(Logger::Level::DEBUG)
200
 
#define warn() Logger(Logger::Level::WARNING)
201
 
#define critical() Logger(Logger::Level::CRITICAL)
202
 
#define error() Logger(Logger::Level::ERROR)
 
52
#define debug() Logger(Logger::Level::DEBUG, G_LOG_DOMAIN)
 
53
#define info() Logger(Logger::Level::INFO, G_LOG_DOMAIN)
 
54
#define warn() Logger(Logger::Level::WARNING, G_LOG_DOMAIN)
 
55
#define critical() Logger(Logger::Level::CRITICAL, G_LOG_DOMAIN)
 
56
#define error() Logger(Logger::Level::ERROR, G_LOG_DOMAIN)
203
57
 
204
58
} // namespace util
205
59