plugins/struts2-dojo-plugin/src/main/resources/org/apache/struts2/static/dojo/src/logging/Logger.js

/*
	Copyright (c) 2004-2006, The Dojo Foundation
	All Rights Reserved.

	Licensed under the Academic Free License version 2.1 or above OR the
	modified BSD license. For more information on Dojo licensing, see:

		http://dojotoolkit.org/community/licensing.shtml
*/



dojo.provide("dojo.logging.Logger");
dojo.provide("dojo.logging.LogFilter");
dojo.provide("dojo.logging.Record");
dojo.provide("dojo.log");
dojo.require("dojo.lang.common");
dojo.require("dojo.lang.declare");
dojo.logging.Record = function (logLevel, message) {
	this.level = logLevel;
	this.message = "";
	this.msgArgs = [];
	this.time = new Date();
	if (dojo.lang.isArray(message)) {
		if (message.length > 0 && dojo.lang.isString(message[0])) {
			this.message = message.shift();
		}
		this.msgArgs = message;
	} else {
		this.message = message;
	}
};
dojo.logging.LogFilter = function (loggerChain) {
	this.passChain = loggerChain || "";
	this.filter = function (record) {
		return true;
	};
};
dojo.logging.Logger = function () {
	this.cutOffLevel = 0;
	this.propagate = true;
	this.parent = null;
	this.data = [];
	this.filters = [];
	this.handlers = [];
};
dojo.extend(dojo.logging.Logger, {_argsToArr:function (args) {
	var ret = [];
	for (var x = 0; x < args.length; x++) {
		ret.push(args[x]);
	}
	return ret;
}, setLevel:function (lvl) {
	this.cutOffLevel = parseInt(lvl);
}, isEnabledFor:function (lvl) {
	return parseInt(lvl) >= this.cutOffLevel;
}, getEffectiveLevel:function () {
	if ((this.cutOffLevel == 0) && (this.parent)) {
		return this.parent.getEffectiveLevel();
	}
	return this.cutOffLevel;
}, addFilter:function (flt) {
	this.filters.push(flt);
	return this.filters.length - 1;
}, removeFilterByIndex:function (fltIndex) {
	if (this.filters[fltIndex]) {
		delete this.filters[fltIndex];
		return true;
	}
	return false;
}, removeFilter:function (fltRef) {
	for (var x = 0; x < this.filters.length; x++) {
		if (this.filters[x] === fltRef) {
			delete this.filters[x];
			return true;
		}
	}
	return false;
}, removeAllFilters:function () {
	this.filters = [];
}, filter:function (rec) {
	for (var x = 0; x < this.filters.length; x++) {
		if ((this.filters[x]["filter"]) && (!this.filters[x].filter(rec)) || (rec.level < this.cutOffLevel)) {
			return false;
		}
	}
	return true;
}, addHandler:function (hdlr) {
	this.handlers.push(hdlr);
	return this.handlers.length - 1;
}, handle:function (rec) {
	if ((!this.filter(rec)) || (rec.level < this.cutOffLevel)) {
		return false;
	}
	for (var x = 0; x < this.handlers.length; x++) {
		if (this.handlers[x]["handle"]) {
			this.handlers[x].handle(rec);
		}
	}
	return true;
}, log:function (lvl, msg) {
	if ((this.propagate) && (this.parent) && (this.parent.rec.level >= this.cutOffLevel)) {
		this.parent.log(lvl, msg);
		return false;
	}
	this.handle(new dojo.logging.Record(lvl, msg));
	return true;
}, debug:function (msg) {
	return this.logType("DEBUG", this._argsToArr(arguments));
}, info:function (msg) {
	return this.logType("INFO", this._argsToArr(arguments));
}, warning:function (msg) {
	return this.logType("WARNING", this._argsToArr(arguments));
}, error:function (msg) {
	return this.logType("ERROR", this._argsToArr(arguments));
}, critical:function (msg) {
	return this.logType("CRITICAL", this._argsToArr(arguments));
}, exception:function (msg, e, squelch) {
	if (e) {
		var eparts = [e.name, (e.description || e.message)];
		if (e.fileName) {
			eparts.push(e.fileName);
			eparts.push("line " + e.lineNumber);
		}
		msg += " " + eparts.join(" : ");
	}
	this.logType("ERROR", msg);
	if (!squelch) {
		throw e;
	}
}, logType:function (type, args) {
	return this.log.apply(this, [dojo.logging.log.getLevel(type), args]);
}, warn:function () {
	this.warning.apply(this, arguments);
}, err:function () {
	this.error.apply(this, arguments);
}, crit:function () {
	this.critical.apply(this, arguments);
}});
dojo.logging.LogHandler = function (level) {
	this.cutOffLevel = (level) ? level : 0;
	this.formatter = null;
	this.data = [];
	this.filters = [];
};
dojo.lang.extend(dojo.logging.LogHandler, {setFormatter:function (formatter) {
	dojo.unimplemented("setFormatter");
}, flush:function () {
}, close:function () {
}, handleError:function () {
	dojo.deprecated("dojo.logging.LogHandler.handleError", "use handle()", "0.6");
}, handle:function (record) {
	if ((this.filter(record)) && (record.level >= this.cutOffLevel)) {
		this.emit(record);
	}
}, emit:function (record) {
	dojo.unimplemented("emit");
}});
void (function () {
	var names = ["setLevel", "addFilter", "removeFilterByIndex", "removeFilter", "removeAllFilters", "filter"];
	var tgt = dojo.logging.LogHandler.prototype;
	var src = dojo.logging.Logger.prototype;
	for (var x = 0; x < names.length; x++) {
		tgt[names[x]] = src[names[x]];
	}
})();
dojo.logging.log = new dojo.logging.Logger();
dojo.logging.log.levels = [{"name":"DEBUG", "level":1}, {"name":"INFO", "level":2}, {"name":"WARNING", "level":3}, {"name":"ERROR", "level":4}, {"name":"CRITICAL", "level":5}];
dojo.logging.log.loggers = {};
dojo.logging.log.getLogger = function (name) {
	if (!this.loggers[name]) {
		this.loggers[name] = new dojo.logging.Logger();
		this.loggers[name].parent = this;
	}
	return this.loggers[name];
};
dojo.logging.log.getLevelName = function (lvl) {
	for (var x = 0; x < this.levels.length; x++) {
		if (this.levels[x].level == lvl) {
			return this.levels[x].name;
		}
	}
	return null;
};
dojo.logging.log.getLevel = function (name) {
	for (var x = 0; x < this.levels.length; x++) {
		if (this.levels[x].name.toUpperCase() == name.toUpperCase()) {
			return this.levels[x].level;
		}
	}
	return null;
};
dojo.declare("dojo.logging.MemoryLogHandler", dojo.logging.LogHandler, {initializer:function (level, recordsToKeep, postType, postInterval) {
	dojo.logging.LogHandler.call(this, level);
	this.numRecords = (typeof djConfig["loggingNumRecords"] != "undefined") ? djConfig["loggingNumRecords"] : ((recordsToKeep) ? recordsToKeep : -1);
	this.postType = (typeof djConfig["loggingPostType"] != "undefined") ? djConfig["loggingPostType"] : (postType || -1);
	this.postInterval = (typeof djConfig["loggingPostInterval"] != "undefined") ? djConfig["loggingPostInterval"] : (postType || -1);
}, emit:function (record) {
	if (!djConfig.isDebug) {
		return;
	}
	var logStr = String(dojo.log.getLevelName(record.level) + ": " + record.time.toLocaleTimeString()) + ": " + record.message;
	if (!dj_undef("println", dojo.hostenv)) {
		dojo.hostenv.println(logStr, record.msgArgs);
	}
	this.data.push(record);
	if (this.numRecords != -1) {
		while (this.data.length > this.numRecords) {
			this.data.shift();
		}
	}
}});
dojo.logging.logQueueHandler = new dojo.logging.MemoryLogHandler(0, 50, 0, 10000);
dojo.logging.log.addHandler(dojo.logging.logQueueHandler);
dojo.log = dojo.logging.log;