source: nrEngine/include/Log.h @ 30

Revision 30, 6.0 KB checked in by art, 12 years ago (diff)

::std wurde durch std ueberall ersetzt!

RevLine 
[1]1/***************************************************************************
2 *                                                                         *
3 *   (c) Art Tevs, MPI Informatik Saarbruecken                             *
4 *       mailto: <tevs@mpi-sb.mpg.de>                                      *
5 *                                                                         *
6 *   This program is free software; you can redistribute it and/or modify  *
7 *   it under the terms of the GNU General Public License as published by  *
8 *   the Free Software Foundation; either version 2 of the License, or     *
9 *   (at your option) any later version.                                   *
10 *                                                                         *
11 ***************************************************************************/
12
13#ifndef __NR_LOG_H_
14#define __NR_LOG_H_
15
16
17//----------------------------------------------------------------------------------
18// Includes
19//----------------------------------------------------------------------------------
20#include "Prerequisities.h"
21#include "Engine.h"
22
23//----------------------------------------------------------------------------------
24// Some usefull macros which makes our life easear
25//----------------------------------------------------------------------------------
26#define NR_Log nrEngine::Engine::sLog()->log
27
28
29namespace nrEngine{
30
31        //! Simple class giving you logging functionality for your application.
32        /**
33        * Log Class is using to generate and print logging information on console,
34        * MessageBox(WIN32) or in a log file on the disk. You can generate log messages
35        * either by giving the message directly or by using message ID-Number of needed.
36        * This guarantee to be log messages not hardcoded and they can also be localized (language). All used
37        * log messages should be stored in an extra file to allow logging by Msg-Id-Number.
38        *
39        * \ingroup engine
40        **/
41        class _NRExport Log{
42                public:
43               
44                        //! Log target is an unsigned integer number
45                        typedef uint32 LogTarget;
46                       
47                        //! Enumeration containing all available log targets
48                        enum {
49                               
50                                //! Log the messages to the client log file. Here you should log all messages coming from client.
51                                LOG_CLIENT = 1 << 0,
52                               
53                                //! Log here messages coming from server if you using networking
54                                LOG_SERVER = 1 << 1,
55                       
56                                //! Use this target to log all application logs coming from your game
57                                LOG_APP = 1 << 2,
58                       
59                                //! This target will be used by kernel to log it's own messages
60                                LOG_KERNEL = 1 << 3,
61                       
62                                //! The engine will use this target to log it own messages. Note: Kernel has got it's own target
63                                LOG_ENGINE = 1 << 4,
64                       
65                                //! This will log to standard console output
66                                LOG_CONSOLE = 1 << 5,
67                       
68                                //! Messages coming from plugins should be logged here
69                                LOG_PLUGIN = 1 << 6,
70
71                                //! Log to all targets above
72                                LOG_ANYTHING = 0xFFFFFFFF
73                        };
74
75                        /**
76                         * Each log message has a certain log level.
77                         * Each log message that should be logged has such kind of information
78                         * about the log level.<br>
79                         * You can specify which kind of level information should be logged.
80                         * All messsages with the type above the specified type will be logged.
81                         * i.e. setting upo the log engine to log messages with LL_WARNING
82                         * will log fatal errors, errors and warnings.
83                         **/
84                        typedef enum _LogLevel{
85                       
86                                //! Messages of this level are produced by fatal errors
87                                LL_FATAL_ERROR = 0,
88
89                                //! This are normal error messages
90                                LL_ERROR,
91
92                                //! Only warning, without an error
93                                LL_WARNING,
94
95                                //! Normal logging, some useful information
96                                LL_NORMAL,
97
98                                //! Just a little bit more information than normal
99                                LL_DEBUG,
100
101                                //! Very verbose message types, say anything anywhere
102                                LL_CHATTY
103
104                        } LogLevel;
105
106                       
107                        /**
108                        * Initialize logging subsystem
109                        * @param logPath - Path to directory where log files will be created
110                        * @return either OK or:
111                        *                       - LOG_ERROR if there was an error by creating the log files
112                        **/
[30]113                        Result initialize(const std::string& logPath);
[1]114                       
115                        /**
116                        * Log any message to the given log target.
117                        * You can bitwise combine log targets (i.e. LOG_CONSOLE | LOG_APP)
118                        * to log to one or more log targets. Each message logged
119                        * through this method will get a normal log level.
120                        * \param target Target where the log message should be written
121                        * \param msg Formatted message to log
122                        **/
123                        void log(LogTarget target, const char* msg, ...);
124
125                        /**
126                        * Same as the normal log function, but here you can specifiy also
127                        * the level of logged messages.
128                        **/
129                        void log(LogTarget target, LogLevel level, const char* msg, ...);
130                                               
131                        /**
132                        * This function will setup logging echo. So you can for example specify
133                        * that all messages given to the engine can be echoing to the console.
134                        * @param from Echo messages from this target
135                        * @param to All messages will be echoed here
136                        **/
137                        void setEcho(LogTarget from, LogTarget to){
138                                _echoMap[(int32)from] = (int32)to;     
139                        }
140
141                        /**
142                        * Setup the default log level. All messages with the level lesser or
143                        * equal to the specified will be logged.
144                        * \param logLevel Level treshold of logged messages
145                        **/
146                        void setLevel(LogLevel logLevel){
147                                _logLevel = logLevel;
148                        }
149
150                                               
151                private:
152
153                        //! Only engine's core class is allowed to create the instance
154                        friend class Engine;
155
156                        /**
157                        * Create an instance of the log subsystem
158                        **/
159                        Log();
160
161                        /**
162                        * Remove the log subsystem from the memory
163                        **/
164                        ~Log();
165
166                        // This are our logging targets
167                        std::ofstream _appLog;
168                        std::ofstream _engineLog;
169                        std::ofstream _clientLog;
170                        std::ofstream _serverLog;
171                        std::ofstream _kernelLog;
172                        std::ofstream _pluginLog;
173
174                        // Log path containing log files
175                        std::string logPath;
176               
177                        // map which stores the logging echo targets
178                        std::map <int32, int32> _echoMap;
179
180                        // Log level information
181                        LogLevel        _logLevel;
182                       
183                        // logging function
184                        void logIt(int32 target, LogLevel level, const char *msg);
185
186                        // get log level string
187                        std::string getLevelStr(LogLevel level);
188                       
189        };
190       
191}; // end namespace
192
193
194#endif
Note: See TracBrowser for help on using the repository browser.