TraceSource.ts
206 lines
| 4.9 KiB
| video/mp2t
|
TypeScriptLexer
cin
|
r9 | import * as format from '../text/format' | |
|
cin
|
r10 | import { argumentNotNull } from '../safe'; | |
|
cin
|
r9 | ||
|
cin
|
r10 | interface TraceEventHandler { | |
| (sender: TraceSource, level: number, arg: any): void; | |||
| } | |||
| interface TraceSourceHandler { | |||
| (source: TraceSource): void; | |||
|
cin
|
r9 | } | |
| interface Destroyable { | |||
| destroy(); | |||
| } | |||
|
cin
|
r10 | class Registry { | |
| static readonly instance = new Registry(); | |||
| private _registry: object = new Object(); | |||
| private _listeners: object = new Object(); | |||
| private _nextCookie: number = 1; | |||
|
cin
|
r9 | ||
|
cin
|
r10 | get(id: any): TraceSource { | |
| argumentNotNull(id, "id"); | |||
| if (this._registry[id]) | |||
| return this._registry[id]; | |||
|
cin
|
r9 | ||
|
cin
|
r10 | var source = new TraceSource(id); | |
| this._registry[id] = source; | |||
| this._onNewSource(source); | |||
| return source; | |||
|
cin
|
r9 | } | |
|
cin
|
r10 | add(id: any, source: TraceSource) { | |
| argumentNotNull(id, "id"); | |||
| argumentNotNull(source, "source"); | |||
| this._registry[id] = source; | |||
| this._onNewSource(source); | |||
| } | |||
| _onNewSource(source: TraceSource) { | |||
| for (let i in this._listeners) | |||
| this._listeners[i].call(null, source); | |||
| } | |||
| on(handler: TraceSourceHandler): Destroyable { | |||
| argumentNotNull(handler, "handler"); | |||
| var me = this; | |||
| var cookie = this._nextCookie++; | |||
| this._listeners[cookie] = handler; | |||
| for (let i in this._registry) | |||
| handler(this._registry[i]); | |||
| return { | |||
| destroy() { | |||
| delete me._listeners[cookie]; | |||
| } | |||
| }; | |||
|
cin
|
r9 | } | |
| } | |||
|
cin
|
r10 | class TraceSource { | |
|
cin
|
r9 | ||
| readonly id: any | |||
|
cin
|
r10 | // using array will provide faster iteration the with object | |
| private _handlers: Array<TraceEventHandler> = new Array<TraceEventHandler>(); | |||
|
cin
|
r9 | ||
| level: number | |||
| constructor(id: any) { | |||
| this.id = id || new Object(); | |||
| } | |||
|
cin
|
r10 | on(handler: TraceEventHandler): Destroyable { | |
| argumentNotNull(handler, "handler"); | |||
| var me = this; | |||
| me._handlers.push(handler); | |||
|
cin
|
r9 | ||
|
cin
|
r10 | return { | |
| destroy() { | |||
| me.remove(handler); | |||
| } | |||
| } | |||
|
cin
|
r9 | } | |
|
cin
|
r10 | remove(handler: TraceEventHandler): void { | |
| let i = this._handlers.indexOf(handler); | |||
|
cin
|
r9 | if (i >= 0) | |
| this._handlers.splice(i, 1); | |||
| } | |||
|
cin
|
r10 | protected emit(level: number, arg: any) { | |
| this._handlers.forEach(h => { | |||
| try { | |||
| h(this, level, arg); | |||
| } catch (e) { | |||
| // suppress error in log handlers | |||
| } | |||
| }); | |||
|
cin
|
r9 | } | |
| isDebugEnabled() { | |||
| return this.level >= TraceSource.DebugLevel; | |||
| } | |||
|
cin
|
r10 | debug(msg: string, ...args: any[]) { | |
| if (this.isEnabled(TraceSource.DebugLevel)) | |||
| this.emit(TraceSource.DebugLevel, format(msg, args)); | |||
|
cin
|
r9 | } | |
| isLogEnabled() { | |||
| return this.level >= TraceSource.LogLevel; | |||
| } | |||
|
cin
|
r10 | log(msg: string, ...args: any[]) { | |
| if (this.isEnabled(TraceSource.LogLevel)) | |||
| this.emit(TraceSource.LogLevel, format(msg, args)); | |||
|
cin
|
r9 | } | |
| isWarnEnabled() { | |||
| return this.level >= TraceSource.WarnLevel; | |||
| } | |||
|
cin
|
r10 | warn(msg: string, ...args: any[]) { | |
| if (this.isEnabled(TraceSource.WarnLevel)) | |||
| this.emit(TraceSource.WarnLevel, format(msg, args)); | |||
|
cin
|
r9 | } | |
|
cin
|
r12 | /** | |
| * returns true if errors will be recorded. | |||
| */ | |||
|
cin
|
r9 | isErrorEnabled() { | |
| return this.level >= TraceSource.ErrorLevel; | |||
| } | |||
|
cin
|
r12 | /** | |
| * Traces a error. | |||
| * | |||
| * @param msg the message. | |||
| * @param args parameters which will be substituted in the message. | |||
| */ | |||
|
cin
|
r10 | error(msg: string, ...args: any[]) { | |
| if (this.isEnabled(TraceSource.ErrorLevel)) | |||
| this.emit(TraceSource.ErrorLevel, format(msg, args)); | |||
| } | |||
|
cin
|
r12 | /** | |
| * Checks whether the specified level is enabled for this | |||
| * trace source. | |||
| * | |||
| * @param level the trace level which should be checked. | |||
| */ | |||
|
cin
|
r10 | isEnabled(level: number) { | |
| return (this.level >= level); | |||
| } | |||
|
cin
|
r12 | /** | |
| * Traces a raw event, passing data as it is to the underlying listeners | |||
| * | |||
| * @param level the level of the event | |||
| * @param arg the data of the event, can be a simple string or any object. | |||
| */ | |||
|
cin
|
r10 | traceEvent(level: number, arg: any) { | |
| if (this.isEnabled(level)) | |||
| this.emit(level, arg); | |||
| } | |||
|
cin
|
r12 | /** | |
| * Register the specified handler to be called for every new and already | |||
| * created trace source. | |||
| * | |||
| * @param handler the handler which will be called for each trace source | |||
| */ | |||
|
cin
|
r10 | static on(handler: TraceSourceHandler) { | |
|
cin
|
r11 | return Registry.instance.on(handler); | |
|
cin
|
r10 | } | |
|
cin
|
r12 | /** | |
| * Creates or returns already created trace source for the specified id. | |||
| * | |||
| * @param id the id for the trace source | |||
| */ | |||
|
cin
|
r10 | static get(id: any) { | |
| return Registry.instance.get(id); | |||
|
cin
|
r9 | } | |
| } | |||
| namespace TraceSource { | |||
| export const DebugLevel = 400; | |||
| export const LogLevel = 300; | |||
| export const WarnLevel = 200; | |||
| export const ErrorLevel = 100; | |||
| export const SilentLevel = 0; | |||
| } | |||
| export = TraceSource; |