rev |
line source |
nuclear@0
|
1 /*
|
nuclear@0
|
2 Open Asset Import Library (assimp)
|
nuclear@0
|
3 ----------------------------------------------------------------------
|
nuclear@0
|
4
|
nuclear@0
|
5 Copyright (c) 2006-2012, assimp team
|
nuclear@0
|
6 All rights reserved.
|
nuclear@0
|
7
|
nuclear@0
|
8 Redistribution and use of this software in source and binary forms,
|
nuclear@0
|
9 with or without modification, are permitted provided that the
|
nuclear@0
|
10 following conditions are met:
|
nuclear@0
|
11
|
nuclear@0
|
12 * Redistributions of source code must retain the above
|
nuclear@0
|
13 copyright notice, this list of conditions and the
|
nuclear@0
|
14 following disclaimer.
|
nuclear@0
|
15
|
nuclear@0
|
16 * Redistributions in binary form must reproduce the above
|
nuclear@0
|
17 copyright notice, this list of conditions and the
|
nuclear@0
|
18 following disclaimer in the documentation and/or other
|
nuclear@0
|
19 materials provided with the distribution.
|
nuclear@0
|
20
|
nuclear@0
|
21 * Neither the name of the assimp team, nor the names of its
|
nuclear@0
|
22 contributors may be used to endorse or promote products
|
nuclear@0
|
23 derived from this software without specific prior
|
nuclear@0
|
24 written permission of the assimp team.
|
nuclear@0
|
25
|
nuclear@0
|
26 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
nuclear@0
|
27 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
nuclear@0
|
28 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
nuclear@0
|
29 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
nuclear@0
|
30 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
nuclear@0
|
31 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
nuclear@0
|
32 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
nuclear@0
|
33 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
nuclear@0
|
34 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
nuclear@0
|
35 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
nuclear@0
|
36 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
nuclear@0
|
37
|
nuclear@0
|
38 ----------------------------------------------------------------------
|
nuclear@0
|
39 */
|
nuclear@0
|
40
|
nuclear@0
|
41 /** @file Logger.hpp
|
nuclear@0
|
42 * @brief Abstract base class 'Logger', base of the logging system.
|
nuclear@0
|
43 */
|
nuclear@0
|
44 #ifndef INCLUDED_AI_LOGGER_H
|
nuclear@0
|
45 #define INCLUDED_AI_LOGGER_H
|
nuclear@0
|
46
|
nuclear@0
|
47 #include "types.h"
|
nuclear@0
|
48 namespace Assimp {
|
nuclear@0
|
49 class LogStream;
|
nuclear@0
|
50
|
nuclear@0
|
51 // Maximum length of a log message. Longer messages are rejected.
|
nuclear@0
|
52 #define MAX_LOG_MESSAGE_LENGTH 1024u
|
nuclear@0
|
53
|
nuclear@0
|
54 // ----------------------------------------------------------------------------------
|
nuclear@0
|
55 /** @brief CPP-API: Abstract interface for logger implementations.
|
nuclear@0
|
56 * Assimp provides a default implementation and uses it for almost all
|
nuclear@0
|
57 * logging stuff ('DefaultLogger'). This class defines just basic logging
|
nuclear@0
|
58 * behaviour and is not of interest for you. Instead, take a look at #DefaultLogger. */
|
nuclear@0
|
59 class ASSIMP_API Logger
|
nuclear@0
|
60 : public Intern::AllocateFromAssimpHeap {
|
nuclear@0
|
61 public:
|
nuclear@0
|
62
|
nuclear@0
|
63 // ----------------------------------------------------------------------
|
nuclear@0
|
64 /** @enum LogSeverity
|
nuclear@0
|
65 * @brief Log severity to describe the granularity of logging.
|
nuclear@0
|
66 */
|
nuclear@0
|
67 enum LogSeverity
|
nuclear@0
|
68 {
|
nuclear@0
|
69 NORMAL, //!< Normal granularity of logging
|
nuclear@0
|
70 VERBOSE //!< Debug infos will be logged, too
|
nuclear@0
|
71 };
|
nuclear@0
|
72
|
nuclear@0
|
73 // ----------------------------------------------------------------------
|
nuclear@0
|
74 /** @enum ErrorSeverity
|
nuclear@0
|
75 * @brief Description for severity of a log message.
|
nuclear@0
|
76 *
|
nuclear@0
|
77 * Every LogStream has a bitwise combination of these flags.
|
nuclear@0
|
78 * A LogStream doesn't receive any messages of a specific type
|
nuclear@0
|
79 * if it doesn't specify the corresponding ErrorSeverity flag.
|
nuclear@0
|
80 */
|
nuclear@0
|
81 enum ErrorSeverity
|
nuclear@0
|
82 {
|
nuclear@0
|
83 Debugging = 1, //!< Debug log message
|
nuclear@0
|
84 Info = 2, //!< Info log message
|
nuclear@0
|
85 Warn = 4, //!< Warn log message
|
nuclear@0
|
86 Err = 8 //!< Error log message
|
nuclear@0
|
87 };
|
nuclear@0
|
88
|
nuclear@0
|
89 public:
|
nuclear@0
|
90
|
nuclear@0
|
91 /** @brief Virtual destructor */
|
nuclear@0
|
92 virtual ~Logger();
|
nuclear@0
|
93
|
nuclear@0
|
94 // ----------------------------------------------------------------------
|
nuclear@0
|
95 /** @brief Writes a debug message
|
nuclear@0
|
96 * @param message Debug message*/
|
nuclear@0
|
97 void debug(const char* message);
|
nuclear@0
|
98 inline void debug(const std::string &message);
|
nuclear@0
|
99
|
nuclear@0
|
100 // ----------------------------------------------------------------------
|
nuclear@0
|
101 /** @brief Writes a info message
|
nuclear@0
|
102 * @param message Info message*/
|
nuclear@0
|
103 void info(const char* message);
|
nuclear@0
|
104 inline void info(const std::string &message);
|
nuclear@0
|
105
|
nuclear@0
|
106 // ----------------------------------------------------------------------
|
nuclear@0
|
107 /** @brief Writes a warning message
|
nuclear@0
|
108 * @param message Warn message*/
|
nuclear@0
|
109 void warn(const char* message);
|
nuclear@0
|
110 inline void warn(const std::string &message);
|
nuclear@0
|
111
|
nuclear@0
|
112 // ----------------------------------------------------------------------
|
nuclear@0
|
113 /** @brief Writes an error message
|
nuclear@0
|
114 * @param message Error message*/
|
nuclear@0
|
115 void error(const char* message);
|
nuclear@0
|
116 inline void error(const std::string &message);
|
nuclear@0
|
117
|
nuclear@0
|
118 // ----------------------------------------------------------------------
|
nuclear@0
|
119 /** @brief Set a new log severity.
|
nuclear@0
|
120 * @param log_severity New severity for logging*/
|
nuclear@0
|
121 void setLogSeverity(LogSeverity log_severity);
|
nuclear@0
|
122
|
nuclear@0
|
123 // ----------------------------------------------------------------------
|
nuclear@0
|
124 /** @brief Get the current log severity*/
|
nuclear@0
|
125 LogSeverity getLogSeverity() const;
|
nuclear@0
|
126
|
nuclear@0
|
127 // ----------------------------------------------------------------------
|
nuclear@0
|
128 /** @brief Attach a new log-stream
|
nuclear@0
|
129 *
|
nuclear@0
|
130 * The logger takes ownership of the stream and is responsible
|
nuclear@0
|
131 * for its destruction (which is done using ::delete when the logger
|
nuclear@0
|
132 * itself is destroyed). Call detachStream to detach a stream and to
|
nuclear@0
|
133 * gain ownership of it again.
|
nuclear@0
|
134 * @param pStream Log-stream to attach
|
nuclear@0
|
135 * @param severity Message filter, specified which types of log
|
nuclear@0
|
136 * messages are dispatched to the stream. Provide a bitwise
|
nuclear@0
|
137 * combination of the ErrorSeverity flags.
|
nuclear@0
|
138 * @return true if the stream has been attached, false otherwise.*/
|
nuclear@0
|
139 virtual bool attachStream(LogStream *pStream,
|
nuclear@0
|
140 unsigned int severity = Debugging | Err | Warn | Info) = 0;
|
nuclear@0
|
141
|
nuclear@0
|
142 // ----------------------------------------------------------------------
|
nuclear@0
|
143 /** @brief Detach a still attached stream from the logger (or
|
nuclear@0
|
144 * modify the filter flags bits)
|
nuclear@0
|
145 * @param pStream Log-stream instance for detaching
|
nuclear@0
|
146 * @param severity Provide a bitwise combination of the ErrorSeverity
|
nuclear@0
|
147 * flags. This value is &~ed with the current flags of the stream,
|
nuclear@0
|
148 * if the result is 0 the stream is detached from the Logger and
|
nuclear@0
|
149 * the caller retakes the possession of the stream.
|
nuclear@0
|
150 * @return true if the stream has been detached, false otherwise.*/
|
nuclear@0
|
151 virtual bool detatchStream(LogStream *pStream,
|
nuclear@0
|
152 unsigned int severity = Debugging | Err | Warn | Info) = 0;
|
nuclear@0
|
153
|
nuclear@0
|
154 protected:
|
nuclear@0
|
155
|
nuclear@0
|
156 /** Default constructor */
|
nuclear@0
|
157 Logger();
|
nuclear@0
|
158
|
nuclear@0
|
159 /** Construction with a given log severity */
|
nuclear@0
|
160 Logger(LogSeverity severity);
|
nuclear@0
|
161
|
nuclear@0
|
162 // ----------------------------------------------------------------------
|
nuclear@0
|
163 /** @brief Called as a request to write a specific debug message
|
nuclear@0
|
164 * @param message Debug message. Never longer than
|
nuclear@0
|
165 * MAX_LOG_MESSAGE_LENGTH characters (excluding the '0').
|
nuclear@0
|
166 * @note The message string is only valid until the scope of
|
nuclear@0
|
167 * the function is left.
|
nuclear@0
|
168 */
|
nuclear@0
|
169 virtual void OnDebug(const char* message)= 0;
|
nuclear@0
|
170
|
nuclear@0
|
171 // ----------------------------------------------------------------------
|
nuclear@0
|
172 /** @brief Called as a request to write a specific info message
|
nuclear@0
|
173 * @param message Info message. Never longer than
|
nuclear@0
|
174 * MAX_LOG_MESSAGE_LENGTH characters (ecxluding the '0').
|
nuclear@0
|
175 * @note The message string is only valid until the scope of
|
nuclear@0
|
176 * the function is left.
|
nuclear@0
|
177 */
|
nuclear@0
|
178 virtual void OnInfo(const char* message) = 0;
|
nuclear@0
|
179
|
nuclear@0
|
180 // ----------------------------------------------------------------------
|
nuclear@0
|
181 /** @brief Called as a request to write a specific warn message
|
nuclear@0
|
182 * @param message Warn message. Never longer than
|
nuclear@0
|
183 * MAX_LOG_MESSAGE_LENGTH characters (exluding the '0').
|
nuclear@0
|
184 * @note The message string is only valid until the scope of
|
nuclear@0
|
185 * the function is left.
|
nuclear@0
|
186 */
|
nuclear@0
|
187 virtual void OnWarn(const char* essage) = 0;
|
nuclear@0
|
188
|
nuclear@0
|
189 // ----------------------------------------------------------------------
|
nuclear@0
|
190 /** @brief Called as a request to write a specific error message
|
nuclear@0
|
191 * @param message Error message. Never longer than
|
nuclear@0
|
192 * MAX_LOG_MESSAGE_LENGTH characters (exluding the '0').
|
nuclear@0
|
193 * @note The message string is only valid until the scope of
|
nuclear@0
|
194 * the function is left.
|
nuclear@0
|
195 */
|
nuclear@0
|
196 virtual void OnError(const char* message) = 0;
|
nuclear@0
|
197
|
nuclear@0
|
198 protected:
|
nuclear@0
|
199
|
nuclear@0
|
200 //! Logger severity
|
nuclear@0
|
201 LogSeverity m_Severity;
|
nuclear@0
|
202 };
|
nuclear@0
|
203
|
nuclear@0
|
204 // ----------------------------------------------------------------------------------
|
nuclear@0
|
205 // Default constructor
|
nuclear@0
|
206 inline Logger::Logger() {
|
nuclear@0
|
207 setLogSeverity(NORMAL);
|
nuclear@0
|
208 }
|
nuclear@0
|
209
|
nuclear@0
|
210 // ----------------------------------------------------------------------------------
|
nuclear@0
|
211 // Virtual destructor
|
nuclear@0
|
212 inline Logger::~Logger()
|
nuclear@0
|
213 {
|
nuclear@0
|
214 }
|
nuclear@0
|
215
|
nuclear@0
|
216 // ----------------------------------------------------------------------------------
|
nuclear@0
|
217 // Construction with given logging severity
|
nuclear@0
|
218 inline Logger::Logger(LogSeverity severity) {
|
nuclear@0
|
219 setLogSeverity(severity);
|
nuclear@0
|
220 }
|
nuclear@0
|
221
|
nuclear@0
|
222 // ----------------------------------------------------------------------------------
|
nuclear@0
|
223 // Log severity setter
|
nuclear@0
|
224 inline void Logger::setLogSeverity(LogSeverity log_severity){
|
nuclear@0
|
225 m_Severity = log_severity;
|
nuclear@0
|
226 }
|
nuclear@0
|
227
|
nuclear@0
|
228 // ----------------------------------------------------------------------------------
|
nuclear@0
|
229 // Log severity getter
|
nuclear@0
|
230 inline Logger::LogSeverity Logger::getLogSeverity() const {
|
nuclear@0
|
231 return m_Severity;
|
nuclear@0
|
232 }
|
nuclear@0
|
233
|
nuclear@0
|
234 // ----------------------------------------------------------------------------------
|
nuclear@0
|
235 inline void Logger::debug(const std::string &message)
|
nuclear@0
|
236 {
|
nuclear@0
|
237 return debug(message.c_str());
|
nuclear@0
|
238 }
|
nuclear@0
|
239
|
nuclear@0
|
240 // ----------------------------------------------------------------------------------
|
nuclear@0
|
241 inline void Logger::error(const std::string &message)
|
nuclear@0
|
242 {
|
nuclear@0
|
243 return error(message.c_str());
|
nuclear@0
|
244 }
|
nuclear@0
|
245
|
nuclear@0
|
246 // ----------------------------------------------------------------------------------
|
nuclear@0
|
247 inline void Logger::warn(const std::string &message)
|
nuclear@0
|
248 {
|
nuclear@0
|
249 return warn(message.c_str());
|
nuclear@0
|
250 }
|
nuclear@0
|
251
|
nuclear@0
|
252 // ----------------------------------------------------------------------------------
|
nuclear@0
|
253 inline void Logger::info(const std::string &message)
|
nuclear@0
|
254 {
|
nuclear@0
|
255 return info(message.c_str());
|
nuclear@0
|
256 }
|
nuclear@0
|
257
|
nuclear@0
|
258 // ----------------------------------------------------------------------------------
|
nuclear@0
|
259
|
nuclear@0
|
260 } // Namespace Assimp
|
nuclear@0
|
261
|
nuclear@0
|
262 #endif // !! INCLUDED_AI_LOGGER_H
|