1 var define = require("../define.js").define, base = require("../base");
  2 
  3 var LEVELS = {
  4 	ALL : -100000,
  5 	DEBUG : 1,
  6 	TRACE : 2,
  7 	INFO : 3,
  8 	WARN :4,
  9 	ERROR : 5,
 10 	FATAL:6,
 11 	OFF : 100000
 12 };
 13 
 14 var LEVELS_REVERSE = {
 15 	"-100000" : "ALL",
 16 	"1" : "DEBUG",
 17 	"2" : "TRACE",
 18 	"3" : "INFO",
 19 	"4": "WARN",
 20 	"5" : "ERROR",
 21 	"6" : "FATAL",
 22 	"100000" : "OFF"
 23 };
 24 
 25 /**
 26  * @class Level class used to describe logging levels. The levels determine what types of events are logged to the appenders
 27  *  for example the if Level.ALL is used then all event will be logged, however if Level.INFO was used then <b>ONLY</b>
 28  *  INFO, WARN, ERROR, and FATAL events will be logged. To turn off logging for a logger use Level.OFF.
 29  *
 30  * <p><b>Not typically instantiated directly, but through staticly defined levels</b></p>
 31  * @example
 32  * //Levels in ascending order
 33  * comb.logging.Level.ALL
 34  * comb.logging.Level.DEBUG
 35  * comb.logging.Level.TRACE
 36  * comb.logging.Level.INFO
 37  * comb.logging.Level.WARN
 38  * comb.logging.Level.ERROR
 39  * comb.logging.Level.FATAL
 40  * comb.logging.Level.OFF
 41  *
 42  * //or
 43  * Level.getLevel("INFO");
 44  *
 45  * @name Level
 46  * @memberOf comb.logging
 47  *
 48  * @property {Number} level the numerical representation of this level.
 49  * @property {String} name the name of level.
 50  */
 51 var Level = (exports = module.exports = define(null, {
 52 			instance : {
 53 				/**@lends comb.logging.Level.prototype*/
 54 
 55 				constructor : function(level, name) {
 56 					this.level = level;
 57 					this.name = name;
 58 				},
 59 
 60 				/**
 61 				 * Determing if this level is >= another level
 62 				 * @param {comb.logging.Level} level the level to test against
 63 				 *
 64 				 * @returns {Boolean} true if this is >= false otherwise.
 65 				 */
 66 				isGreaterOrEqualToo : function(level) {
 67 					var ret = false;
 68 					if (level && level instanceof Level) {
 69 						if (this.level >= level.level) {
 70 							ret = true;
 71 						}
 72 					}
 73 					return ret;
 74 				},
 75 
 76 				/**
 77 				 * Determing if this level is equal to another level based off of the numerical rank.
 78 				 *
 79 				 * @param {comb.logging.Level} level the level to compare
 80 				 *
 81 				 * @returns {Boolean} true if this is equal to that false otherwise.
 82 				 */
 83 				equals : function(level) {
 84 					return level.level == this.level;
 85 				}
 86 			},
 87 			static : {
 88 				/**@lends comb.logging.Level*/
 89 
 90 				/**
 91 				 * Converts a numerical or string representation of a level, if a default level is provided,
 92 				 * then if a level cannot be determined then the default level is used.
 93 				 *
 94 				 * @param {Number|String|comb.logging.Level} level the level to try to convert
 95 				 * @param {comb.logging.Level} [defaultLevel] default level to use if one cannot be determined,
 96 				 *
 97 				 * @returns {comb.logging.Level|null} returns a level if one can be determined null otherwise.
 98 				 */
 99 				toLevel : function(level, defaultLevel) {
100 					var ret = null;
101 					var args = base.argsToArray(arguments);
102 					if (args.length === 1) {
103 						var level = args[0];
104 						if (level instanceof Level) {
105 							ret = level;
106 						} else if (base.isNumber(level)) {
107 							var strLevel = LEVELS_REVERSE[level];
108 							ret = Level[strLevel];
109 						} else if (base.isString(level)) {
110 							ret = Level[level.toUpperCase()];
111 						}
112 					} else {
113 						ret = (Level.toLevel(args[0]) || args[1]);
114 					}
115 					return ret;
116 				},
117 
118                 /**
119                  * Adds a new level to the Level object.
120                  *
121                  * @example
122                  *
123                  * logger = Logger.getLogger("my.logger");
124                  *
125                  * //create the custom level
126                  * Level.addLevel("custom_Level", 20);
127                  *
128                  * //now set the level on a logger
129                  * logger.level = Level.CUSTOM_LEVEL;
130                  *
131                  * @param {string} label the label of the level, <b>Note:</b> the label will be coverted to uppercase.
132                  * @param {number} level the level of the level
133                  *
134                  * @return {undefined|comb.logging.Level} the level that was created.
135                  *
136                  */
137                 addLevel : function(label, level){
138                     var ret;
139                     if(base.isString(label) && base.isNumber(level)){
140                         label = label.toUpperCase();
141                         LEVELS_REVERSE[level] = label;
142                         LEVELS[label] = level;
143                         ret = (this[label] = new Level(level, label));
144                     }
145                     return ret;
146                 },
147 
148 				/**
149 				 * Level to allow logging of all events.
150 				 */
151 				ALL : null,
152 				/**
153 				 * Logs only events debug or greater.
154 				 */
155 				DEBUG : null,
156 				/**
157 				 * Like debug but provides a finer level of detail
158 				 */
159 				TRACE : null,
160 				/**
161 				 * Only info, or error related events
162 				 */
163 				INFO : null,
164 				/**
165 				 * Only warn or error related events
166 				 */
167 				WARN : null,
168 				/**
169 				 * Error or fatal events
170 				 */
171 				ERROR : null,
172 				/**
173 				 * Only fatal events
174 				 */
175 				FATAL : null,
176 				/**
177 				 * No events will be logged.
178 				 */
179 				OFF : null
180 
181 			}
182 		}));
183 
184 for (var i in LEVELS_REVERSE) {
185 	Level[LEVELS_REVERSE[i]] = new Level(parseInt(i, 10), LEVELS_REVERSE[i]);
186 }