← Back to branch summary

~ppsspp/ppsspp/ppsspp_1.3.0

« back to all changes in this revision

Viewing changes to Common/LogManager.h

  • Committer: Sérgio Benjamim
  • Date: 2017-01-02 00:12:05 UTC
  • Revision ID: sergio_br2@yahoo.com.br-20170102001205-cxbta9za203nmjwm
1.3.0 source (from ppsspp_1.3.0-r160.p5.l1762.a165.t83~56~ubuntu16.04.1.tar.xz).

Show diffs side-by-side

added added

removed removed

Lines of Context:
Common/LogManager.h
 
1
// Copyright (C) 2003 Dolphin Project.
 
2
 
 
3
// This program is free software: you can redistribute it and/or modify
 
4
// it under the terms of the GNU General Public License as published by
 
5
// the Free Software Foundation, version 2.0 or later versions.
 
6
 
 
7
// This program is distributed in the hope that it will be useful,
 
8
// but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
// GNU General Public License 2.0 for more details.
 
11
 
 
12
// A copy of the GPL 2.0 should have been included with the program.
 
13
// If not, see http://www.gnu.org/licenses/
 
14
 
 
15
// Official SVN repository and contact information can be found at
 
16
// http://code.google.com/p/dolphin-emu/
 
17
 
 
18
#pragma once
 
19
 
 
20
#include <set>
 
21
#include "base/mutex.h"
 
22
#include "file/ini_file.h"
 
23
#include "Log.h"
 
24
#include "StringUtils.h"
 
25
#include "FileUtil.h"
 
26
 
 
27
#define MAX_MESSAGES 8000   
 
28
#define MAX_MSGLEN  1024
 
29
 
 
30
extern const char *hleCurrentThreadName;
 
31
 
 
32
// pure virtual interface
 
33
class LogListener {
 
34
public:
 
35
        virtual ~LogListener() {}
 
36
 
 
37
        virtual void Log(LogTypes::LOG_LEVELS, const char *msg) = 0;
 
38
};
 
39
 
 
40
class FileLogListener : public LogListener {
 
41
public:
 
42
        FileLogListener(const char *filename);
 
43
 
 
44
        void Log(LogTypes::LOG_LEVELS, const char *msg);
 
45
 
 
46
        bool IsValid() { if (!m_logfile) return false; else return true; }
 
47
        bool IsEnabled() const { return m_enable; }
 
48
        void SetEnable(bool enable) { m_enable = enable; }
 
49
 
 
50
        const char* GetName() const { return "file"; }
 
51
 
 
52
private:
 
53
        recursive_mutex m_log_lock;
 
54
        std::ofstream m_logfile;
 
55
        bool m_enable;
 
56
};
 
57
 
 
58
class DebuggerLogListener : public LogListener {
 
59
public:
 
60
        void Log(LogTypes::LOG_LEVELS, const char *msg);
 
61
};
 
62
 
 
63
class RingbufferLogListener : public LogListener {
 
64
public:
 
65
        RingbufferLogListener() : curMessage_(0), count_(0), enabled_(false) {}
 
66
        void Log(LogTypes::LOG_LEVELS, const char *msg);
 
67
 
 
68
        bool IsEnabled() const { return enabled_; }
 
69
        void SetEnable(bool enable) { enabled_ = enable; }
 
70
 
 
71
        int GetCount() const { return count_ < MAX_LOGS ? count_ : MAX_LOGS; }
 
72
        const char *TextAt(int i) { return messages_[(curMessage_ - i - 1) & (MAX_LOGS - 1)]; }
 
73
        LogTypes::LOG_LEVELS LevelAt(int i) { return (LogTypes::LOG_LEVELS)levels_[(curMessage_ - i - 1) & (MAX_LOGS - 1)]; }
 
74
 
 
75
private:
 
76
        enum { MAX_LOGS = 128 };
 
77
        char messages_[MAX_LOGS][1024];
 
78
        u8 levels_[MAX_LOGS];
 
79
        int curMessage_;
 
80
        int count_;
 
81
        bool enabled_;
 
82
};
 
83
 
 
84
// TODO: A simple buffered log that can be used to display the log in-window
 
85
// on Android etc.
 
86
// class BufferedLogListener { ... }
 
87
 
 
88
class LogChannel {
 
89
public:
 
90
        LogChannel(const char* shortName, const char* fullName, bool enable = false);
 
91
        
 
92
        const char* GetShortName() const { return m_shortName; }
 
93
        const char* GetFullName() const { return m_fullName; }
 
94
 
 
95
        void AddListener(LogListener* listener);
 
96
        void RemoveListener(LogListener* listener);
 
97
 
 
98
        void Trigger(LogTypes::LOG_LEVELS, const char *msg);
 
99
 
 
100
        bool IsEnabled() const { return enable_; }
 
101
        void SetEnable(bool enable) { enable_ = enable; }
 
102
 
 
103
        LogTypes::LOG_LEVELS GetLevel() const { return (LogTypes::LOG_LEVELS)level_; }
 
104
 
 
105
        void SetLevel(LogTypes::LOG_LEVELS level) {     level_ = level; }
 
106
        bool HasListeners() const { return m_hasListeners; }
 
107
 
 
108
        // Although not elegant, easy to set with a PopupMultiChoice...
 
109
        int level_;
 
110
        bool enable_;
 
111
 
 
112
private:
 
113
        char m_fullName[128];
 
114
        char m_shortName[32];
 
115
        recursive_mutex m_listeners_lock;
 
116
        std::set<LogListener*> m_listeners;
 
117
        bool m_hasListeners;
 
118
};
 
119
 
 
120
class ConsoleListener;
 
121
 
 
122
class LogManager : NonCopyable {
 
123
private:
 
124
        LogChannel* log_[LogTypes::NUMBER_OF_LOGS];
 
125
        FileLogListener *fileLog_;
 
126
        ConsoleListener *consoleLog_;
 
127
        DebuggerLogListener *debuggerLog_;
 
128
        RingbufferLogListener *ringLog_;
 
129
        static LogManager *logManager_;  // Singleton. Ugh.
 
130
        recursive_mutex log_lock_;
 
131
 
 
132
        LogManager();
 
133
        ~LogManager();
 
134
 
 
135
public:
 
136
 
 
137
        static u32 GetMaxLevel() { return MAX_LOGLEVEL; }
 
138
        static int GetNumChannels() { return LogTypes::NUMBER_OF_LOGS; }
 
139
 
 
140
        void Log(LogTypes::LOG_LEVELS level, LogTypes::LOG_TYPE type, 
 
141
                         const char *file, int line, const char *fmt, va_list args);
 
142
        bool IsEnabled(LogTypes::LOG_LEVELS level, LogTypes::LOG_TYPE type);
 
143
 
 
144
        LogChannel *GetLogChannel(LogTypes::LOG_TYPE type) {
 
145
                return log_[type];
 
146
        }
 
147
 
 
148
        void SetLogLevel(LogTypes::LOG_TYPE type, LogTypes::LOG_LEVELS level) {
 
149
                log_[type]->SetLevel(level);
 
150
        }
 
151
 
 
152
        void SetAllLogLevels(LogTypes::LOG_LEVELS level) {
 
153
                for (int i = 0; i < LogTypes::NUMBER_OF_LOGS; ++i) {
 
154
                        log_[i]->SetLevel(level);
 
155
                }
 
156
        }
 
157
 
 
158
        void SetEnable(LogTypes::LOG_TYPE type, bool enable) {
 
159
                log_[type]->SetEnable(enable);
 
160
        }
 
161
 
 
162
        LogTypes::LOG_LEVELS GetLogLevel(LogTypes::LOG_TYPE type) {
 
163
                return log_[type]->GetLevel();
 
164
        }
 
165
 
 
166
        void AddListener(LogTypes::LOG_TYPE type, LogListener *listener) {
 
167
                log_[type]->AddListener(listener);
 
168
        }
 
169
 
 
170
        void RemoveListener(LogTypes::LOG_TYPE type, LogListener *listener) {
 
171
                log_[type]->RemoveListener(listener);
 
172
        }
 
173
 
 
174
        ConsoleListener *GetConsoleListener() const {
 
175
                return consoleLog_;
 
176
        }
 
177
 
 
178
        DebuggerLogListener *GetDebuggerListener() const {
 
179
                return debuggerLog_;
 
180
        }
 
181
 
 
182
        RingbufferLogListener *GetRingbufferListener() const {
 
183
                return ringLog_;
 
184
        }
 
185
 
 
186
        static inline LogManager* GetInstance() {
 
187
                return logManager_;
 
188
        }
 
189
 
 
190
        static void SetInstance(LogManager *logManager) {
 
191
                logManager_ = logManager;
 
192
        }
 
193
 
 
194
        static void Init();
 
195
        static void Shutdown();
 
196
 
 
197
        void ChangeFileLog(const char *filename);
 
198
 
 
199
  void SaveConfig(IniFile::Section *section);
 
200
  void LoadConfig(IniFile::Section *section);
 
201
};