1 //jls.loader.provide('jls.lang.Logger');
  2 
  3 /**
  4  * @class Default logger implementation.
  5  * A Logger object is used to log messages for a specific system or application component.
  6  */
  7 jls.lang.Logger = jls.lang.Class.create(/** @lends jls.lang.Logger.prototype */
  8 {
  9     initialize : function(level) {
 10         this._level = level || jls.lang.Logger.INFO;
 11     },
 12     getLogLevel : function() {
 13         return this._level;
 14     },
 15     setLogLevel : function(level) {
 16         if (typeof level == 'number') {
 17             this._level = level;
 18         } else if (typeof level == 'string') {
 19             level = level.toUpperCase();
 20             if (level in jls.lang.Logger) {
 21                 this._level = jls.lang.Logger[level];
 22             }
 23         }
 24     },
 25     /**
 26      * Tells if the log level trace is enabled.
 27      * 
 28      * @returns {Boolean} true if the log level trace is enabled; false otherwise.
 29      */
 30     isTraceEnabled : function() {
 31         return this.isEnabledFor(jls.lang.Logger.TRACE);
 32     },
 33     /**
 34      * Tells if the log level debug is enabled.
 35      * 
 36      * @returns {Boolean} true if the log level debug is enabled; false otherwise.
 37      */
 38     isDebugEnabled : function() {
 39         return this.isEnabledFor(jls.lang.Logger.DEBUG);
 40     },
 41     isEnabledFor : function(level) {
 42         return this._level <= level;
 43     },
 44     /**
 45      * Logs a specified message using the trace level.
 46      * 
 47      * @param {String} msg The message to log.
 48      */
 49     trace : function(msg) {
 50         this.log(jls.lang.Logger.TRACE, msg);
 51     },
 52     /**
 53      * Logs a specified message using the debug level.
 54      * 
 55      * @param {String} msg The message to log.
 56      */
 57     debug : function(msg) {
 58         this.log(jls.lang.Logger.DEBUG, msg);
 59     },
 60     /**
 61      * Logs a specified message using the info level.
 62      * 
 63      * @param {String} msg The message to log.
 64      */
 65     info : function(msg) {
 66         this.log(jls.lang.Logger.INFO, msg);
 67     },
 68     /**
 69      * Logs a specified message using the warn level.
 70      * 
 71      * @param {String} msg The message to log.
 72      */
 73     warn : function(msg) {
 74         this.log(jls.lang.Logger.WARN, msg);
 75     },
 76     /**
 77      * Logs a specified message using the error level.
 78      * 
 79      * @param {String} msg The message to log.
 80      */
 81     error : function(msg) {
 82         this.log(jls.lang.Logger.ERROR, msg);
 83     },
 84     logObject : function(level, msg, o) {
 85         if (this._level > level) {
 86             return;
 87         }
 88         this.log(level, msg + ': ' + o);
 89         for (var k in o) {
 90             if (typeof (o[k]) == 'function') {
 91                 this.log(level, ' ' + k + '()');
 92             } else {
 93                 this.log(level, ' ' + k + ': ' + o[k]);
 94             }
 95         }
 96     },
 97     logBuffer : function(level, buffer, message) {
 98         if (this._level > level) {
 99             return;
100         }
101         var buffer = buffer.slice();
102         this.log(level, (message ? message : 'buffer') + ' (' + buffer.remaining() + '):');
103         var w = 16;
104         var hex = '0123456789abcdef';
105         for (var l = 0; buffer.remaining() > 0; l += w) {
106             var lineHex = '';
107             var lineAsc = '';
108             for (var c = 0; c < w; c++) {
109                 if (buffer.remaining() == 0) {
110                     lineHex += '   ';
111                     lineAsc += ' ';
112                     continue;
113                 }
114                 var b = buffer.getByte();
115                 lineHex += hex.charAt(b >> 4) + hex.charAt(b & 0x0f) + ' ';
116                 lineAsc += b > 31 && b < 128 ? String.fromCharCode(b) : ' ';
117             }
118             this.log(level, lineHex + lineAsc);
119         }
120     },
121     log : function(level, msg) {
122         if (this._level > level) {
123             return;
124         }
125         /*if ((level < jls.lang.Logger.FINEST) || (level > jls.lang.Logger.ERROR)) {
126             throw new jls.lang.Exception("Invalid log level " + level);
127         }*/
128         _native.core.log(level, msg);
129     }
130 });
131 
132 /*
133  * Could be used as the following:
134  * new jls.lang.Exception().printStackTrace(new jls.lang.Logger.PrintStream(jls.logger, jls.lang.Logger.WARN));
135  */
136 jls.lang.Logger.PrintStream = jls.lang.Class.create({
137     initialize : function(logger, level) {
138         this._logger = logger;
139         this._level = level || jls.lang.Logger.DEBUG;
140         this._buffer = null;
141     },
142     flush : function() {
143         if (this._buffer != null) {
144             this._logger.log(this._level, this._buffer);
145             this._buffer = null;
146         }
147         return this;
148     },
149     print : function(s) {
150         if (this._buffer == null) {
151             this._buffer = s;
152         } else {
153             this._buffer += s;
154         }
155         if (s.indexOf('\n') >= 0) {
156             this.flush();
157         }
158         return s.length;
159     },
160     println : function(s) {
161         if (s) {
162             return this.print(s + jls.io.PrintStream.separator);
163         } else {
164             return this.print(jls.io.PrintStream.separator);
165         }
166     }
167 });
168 
169 Object.extend(jls.lang.Logger, /** @lends jls.lang.Logger */
170 {
171     /**
172      * The finest log level.
173      * @type Number
174      */
175     FINEST: 1,
176     /**
177      * The fine log level.
178      * @type Number
179      */
180     FINE:   2,
181     /**
182      * The trace log level.
183      * @type Number
184      */
185     TRACE:  3,
186     /**
187      * The debug log level.
188      * @type Number
189      */
190     DEBUG:  4,
191     /**
192      * The info log level.
193      * @type Number
194      */
195     INFO:   5,
196     /**
197      * The warn log level.
198      * @type Number
199      */
200     WARN:   6,
201     /**
202      * The error log level.
203      * @type Number
204      */
205     ERROR:  7
206 });
207 
208