1 /* 2 * Copyright the original author or authors. 3 * 4 * Licensed under the MOZILLA PUBLIC LICENSE, Version 1.1 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.mozilla.org/MPL/MPL-1.1.html 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 import org.as2lib.core.BasicClass; 18 import org.as2lib.env.log.Logger; 19 20 import net.hiddenresource.util.Debug; 21 22 /** 23 * {@code AlconLogger} delegates all messages to the 24 * {@code net.hiddenresource.util.Debug.trace} method. 25 * 26 * <p>Using this class instead of the {@code Debug} class in your application 27 * directly enables you to switch between almost every available Logging API without 28 * having to change the logging calls but just the configuration on startup. 29 * 30 * <p>Every global configuration must be done via the static methods on the 31 * {@code Debug} class itself. 32 * 33 * @author Simon Wacker 34 * @see org.as2lib.env.log.handler.AlconHandler 35 * @see <a href="http://hiddenresource.corewatch.net/index.php?itemid=17">Alcon</a> 36 */ 37 class org.as2lib.env.log.logger.AlconLogger extends BasicClass implements Logger { 38 39 /** Alcon debug level. */ 40 public static var DEBUG:Number = 0; 41 42 /** Alcon info level. */ 43 public static var INFO:Number = 1; 44 45 /** Alcon warn level. */ 46 public static var WARN:Number = 2; 47 48 /** Alcon error level. */ 49 public static var ERROR:Number = 3; 50 51 /** Alcon fatal level. */ 52 public static var FATAL:Number = 4; 53 54 /** Determines whether to trace recursively or not. */ 55 private var recursiveTracing:Boolean; 56 57 /** Alcon debug level. */ 58 private var debugLevel:Number; 59 60 /** Alcon info level. */ 61 private var infoLevel:Number; 62 63 /** Alcon warn level. */ 64 private var warnLevel:Number; 65 66 /** Alcon error level. */ 67 private var errorLevel:Number; 68 69 /** Alcon fatal level. */ 70 private var fatalLevel:Number; 71 72 /** 73 * Constructs a new {@code AlconLogger} instance. 74 * 75 * <p>The default value for {@code recursiveTracing} is {@code true}. 76 * 77 * @param recursiveTracing (optional) determines whether to trace messages 78 * recursively 79 */ 80 public function AlconLogger(recursiveTracing:Boolean) { 81 this.recursiveTracing = recursiveTracing == null ? true : recursiveTracing; 82 this.debugLevel = DEBUG; 83 this.infoLevel = INFO; 84 this.warnLevel = WARN; 85 this.errorLevel = ERROR; 86 this.fatalLevel = FATAL; 87 } 88 89 /** 90 * Checks if this logger is enabled for debug level messages. 91 * 92 * @return {@code true} if debug messages are logged 93 * @see #debug 94 */ 95 public function isDebugEnabled(Void):Boolean { 96 return (Debug.getFilterLevel() <= this.debugLevel); 97 } 98 99 /** 100 * Checks if this logger is enabled for info level messages. 101 * 102 * @return {@code true} if info messages are logged 103 * @see #info 104 */ 105 public function isInfoEnabled(Void):Boolean { 106 return (Debug.getFilterLevel() <= this.infoLevel); 107 } 108 109 /** 110 * Checks if this logger is enabled for warning level messages. 111 * 112 * @return {@code true} if warning messages are logged 113 * @see #warning 114 */ 115 public function isWarningEnabled(Void):Boolean { 116 return (Debug.getFilterLevel() <= this.warnLevel); 117 } 118 119 /** 120 * Checks if this logger is enabled for error level messages. 121 * 122 * @return {@code true} if error messages are logged 123 * @see #error 124 */ 125 public function isErrorEnabled(Void):Boolean { 126 return (Debug.getFilterLevel() <= this.errorLevel); 127 } 128 129 /** 130 * Checks if this logger is enabled for fatal level messages. 131 * 132 * @return {@code true} if fatal messages are logged 133 * @see #fatal 134 */ 135 public function isFatalEnabled(Void):Boolean { 136 return (Debug.getFilterLevel() <= this.fatalLevel); 137 } 138 139 /** 140 * Logs the passed-in {@code message} at debug level. 141 * 142 * <p>The {@code message} is only logged when the level is set to debug or a level 143 * above. 144 * 145 * <p>The {@code message} is logged using the {@code Alcon.trace} method, passing 146 * the debug level number. 147 * 148 * @param message the message object to log 149 * @see #isDebugEnabled 150 */ 151 public function debug(message):Void { 152 Debug.trace(message, this.debugLevel, this.recursiveTracing); 153 } 154 155 /** 156 * Logs the passed-in {@code message} at info level. 157 * 158 * <p>The {@code message} is only logged when the level is set to info or a level 159 * above. 160 * 161 * <p>The {@code message} is logged using the {@code Alcon.trace} method, passing 162 * the info level number. 163 * 164 * @param message the message object to log 165 * @see #isInfoEnabled 166 */ 167 public function info(message):Void { 168 Debug.trace(message, this.infoLevel, this.recursiveTracing); 169 } 170 171 /** 172 * Logs the passed-in {@code message} at warning level. 173 * 174 * <p>The {@code message} is only logged when the level is set to warning or a 175 * level above. 176 * 177 * <p>The {@code message} is logged using the {@code Alcon.trace} method, passing 178 * the warn level number. 179 * 180 * @param message the message object to log 181 * @see #isWarningEnabled 182 */ 183 public function warning(message):Void { 184 Debug.trace(message, this.warnLevel, this.recursiveTracing); 185 } 186 187 /** 188 * Logs the passed-in {@code message} at error level. 189 * 190 * <p>The {@code message} is only logged when the level is set to error or a level 191 * above. 192 * 193 * <p>The {@code message} is logged using the {@code Alcon.trace} method, passing 194 * the error level number. 195 * 196 * @param message the message object to log 197 * @see #isErrorEnabled 198 */ 199 public function error(message):Void { 200 Debug.trace(message, this.errorLevel, this.recursiveTracing); 201 } 202 203 /** 204 * Logs the passed-in {@code message} at fatal level. 205 * 206 * <p>The {@code message} is only logged when the level is set to fatal or a level 207 * above. 208 * 209 * <p>The {@code message} is logged using the {@code Alcon.trace} method, passing 210 * the fatal level number. 211 * 212 * @param message the message object to log 213 * @see #isFatalEnabled 214 */ 215 public function fatal(message):Void { 216 Debug.trace(message, this.fatalLevel, this.recursiveTracing); 217 } 218 219 }