]> git.jsancho.org Git - lugaru.git/blob - Source/logger/Copy of logger.h
Changed data dir mentioned in makefile.
[lugaru.git] / Source / logger / Copy of logger.h
1 // ---------------------------------------------------------------------------------------------------------------------------------
2 //  _                                 _     
3 // | |                               | |    
4 // | | ___   __ _  __ _  ___ _ __    | |__  
5 // | |/ _ \ / _` |/ _` |/ _ \ '__|   | '_ \ 
6 // | | (_) | (_| | (_| |  __/ |    _ | | | |
7 // |_|\___/ \__, |\__, |\___|_|   (_)|_| |_|
8 //           __/ | __/ |                    
9 //          |___/ |___/                     
10 //
11 // Generic informational logging class
12 //
13 // ---------------------------------------------------------------------------------------------------------------------------------
14 //
15 // Restrictions & freedoms pertaining to usage and redistribution of this software:
16 //
17 //  * This software is 100% free
18 //  * If you use this software (in part or in whole) you must credit the author.
19 //  * This software may not be re-distributed (in part or in whole) in a modified
20 //    form without clear documentation on how to obtain a copy of the original work.
21 //  * You may not use this software to directly or indirectly cause harm to others.
22 //  * This software is provided as-is and without warrantee. Use at your own risk.
23 //
24 // For more information, visit HTTP://www.FluidStudios.com
25 //
26 // ---------------------------------------------------------------------------------------------------------------------------------
27 // Originally created on 07/06/2000 by Paul Nettle
28 //
29 // Copyright 2000, Fluid Studios, Inc., all rights reserved.
30 // ---------------------------------------------------------------------------------------------------------------------------------
31
32 #ifndef _H_LOGGER
33 #define _H_LOGGER
34
35 // ---------------------------------------------------------------------------------------------------------------------------------
36 // The global logger
37 // ---------------------------------------------------------------------------------------------------------------------------------
38
39 class   Logger;
40 extern  Logger  logger;
41
42 // ---------------------------------------------------------------------------------------------------------------------------------
43 // Macros (necessary evil to take advantage of __LINE__ and __FILE__)
44 // ---------------------------------------------------------------------------------------------------------------------------------
45
46 #define LOG             logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__,logger.logTex
47 #define HEX             logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__,logger.logHex
48 #define RAW             logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__,logger.logRaw
49 #define INDENT          logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__,logger.indent
50 #define UNDENT          logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__,logger.undent
51 #define LOGBLOCK        logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__;LogBlock __lb__
52
53 // If you compiler supports __FUNCTION__, then replace the "#if 1" with "#if 0". Note that this will change the usage of the macro
54
55 #if 0
56 #define LOGFUNC         logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__;LogFlow __lf__
57 #else
58 #define LOGFUNC         logger.sourceLine() = __LINE__, logger.sourceFile() = __FILE__;LogFlow __lf__(__FUNCTION__)
59 #endif
60
61 // ---------------------------------------------------------------------------------------------------------------------------------
62 // The logger class: does the actual logging
63 // ---------------------------------------------------------------------------------------------------------------------------------
64
65 class   Logger
66 {
67 public:
68         // Enumerations
69
70         enum    LogFlags
71         {
72                                 LOG_INDENT = 0x00000001,
73                                 LOG_UNDENT = 0x00000002,
74                                 LOG_FLOW   = 0x00000004,
75                                 LOG_BLOK   = 0x00000008,
76                                 LOG_DATA   = 0x00000010,
77                                 LOG_INFO   = 0x00000012,
78                                 LOG_WARN   = 0x00000014,
79                                 LOG_ERR    = 0x00000018,
80                                 LOG_CRIT   = 0x00000020,
81                                 LOG_ALL    = 0xFFFFFFFF
82         };
83
84         // Construction/Destruction
85
86 inline                          Logger()
87                                 : _sourceLine(0), _indentCount(0), _indentChars(4), _fileSizeLimit(-1), _logMask(LOG_ALL),
88                                   _logStarted(false), _lineCharsFlag(false), _logFile("logger.log")
89                                 {
90                                 }
91
92 virtual                         ~Logger()
93                                 {
94                                         stop();
95                                 }
96
97         // Operators
98
99 inline          void            operator +=(const string &s)    {logTex(s);}
100
101         // Accessors
102
103 inline  const   bool            &lineCharsFlag() const  {return _lineCharsFlag;}
104 inline          bool            &lineCharsFlag()        {return _lineCharsFlag;}
105
106 inline  const   int             &fileSizeLimit() const  {return _fileSizeLimit;}
107 inline          int             &fileSizeLimit()        {return _fileSizeLimit;}
108
109 inline  const   unsigned int    &logMask() const        {return _logMask;}
110 inline          unsigned int    &logMask()              {return _logMask;}
111
112 inline  const   string          &logFile() const        {return _logFile;}
113 inline          string          &logFile()              {return _logFile;}
114
115 inline  const   unsigned int    &sourceLine() const     {return _sourceLine;}
116 inline          unsigned int    &sourceLine()           {return _sourceLine;}
117
118 inline  const   string          &sourceFile() const     {return _sourceFile;}
119 inline          string          &sourceFile()           {return _sourceFile;}
120
121 inline          bool            logStarted() const      {return _logStarted;}
122
123         // Utilitarian (public)
124
125 virtual         void            start(const bool reset);
126 virtual         void            stop();
127 virtual         void            logTex(const string &s, const LogFlags logBits = LOG_INFO);
128 virtual         void            logRaw(const string &s);
129 virtual         void            logHex(const char *buffer, const unsigned int count, const LogFlags logBits = LOG_INFO);
130 virtual         void            indent(const string &s, const LogFlags logBits = LOG_INDENT);
131 virtual         void            undent(const string &s, const LogFlags logBits = LOG_UNDENT);
132
133 private:
134         // Utilitarian (private)
135
136 virtual         void            limitFileSize() const;
137 virtual const   string          &headerString(const LogFlags logBits) const;
138
139         // Data
140
141                 string          _logFile;
142                 string          _sourceFile;
143                 unsigned int    _sourceLine;
144                 int             _indentCount;
145                 int             _indentChars;
146                 int             _fileSizeLimit;
147                 unsigned int    _logMask;
148                 bool            _logStarted;
149                 bool            _lineCharsFlag;
150 };
151
152 // ---------------------------------------------------------------------------------------------------------------------------------
153 // The LogBlock class: used for automatic indentation
154 // ---------------------------------------------------------------------------------------------------------------------------------
155
156 class   LogBlock
157 {
158 public:
159 inline                          LogBlock(const string &s)       {str = s;logger.indent("Begin block: " + str, Logger::LOG_INDENT);}
160 inline                          ~LogBlock()                     {logger.undent("", Logger::LOG_UNDENT);}
161 private:
162                 string          str;
163 };
164
165 // ---------------------------------------------------------------------------------------------------------------------------------
166 // The LogFlow class: used for logging code flow
167 // ---------------------------------------------------------------------------------------------------------------------------------
168
169 void pushFunc(void);
170 void popFunc(void);
171 void dumpLog(void);
172
173 class   LogFlow
174 {
175 public:
176 inline                          LogFlow(const string &function) {pushFunc(); str = function;logger.indent(str, Logger::LOG_FLOW);}
177 inline                          ~LogFlow()                      {logger.undent("", Logger::LOG_FLOW); popFunc();}
178 private:
179                 string          str;
180 };
181
182 #endif // _H_LOGGER
183 // ---------------------------------------------------------------------------------------------------------------------------------
184 // logger.h - End of file
185 // ---------------------------------------------------------------------------------------------------------------------------------
186