TraceSource.ts
170 lines
| 4.2 KiB
| video/mp2t
|
TypeScriptLexer
cin
|
r9 | import * as format from '../text/format' | |
|
cin
|
r10 | import { argumentNotNull } from '../safe'; | |
|
cin
|
r14 | import * as Observable from '../components/Observable' | |
| import { IDestroyable } from '../interfaces'; | |||
| import * as TraceEvent from './TraceEvent' | |||
|
cin
|
r9 | ||
|
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); | |||
| } | |||
|
cin
|
r14 | on(handler: (source: TraceSource) => void): IDestroyable { | |
|
cin
|
r10 | 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
|
r14 | class TraceSource extends Observable<TraceEvent> { | |
|
cin
|
r9 | readonly id: any | |
| level: number | |||
| constructor(id: any) { | |||
|
cin
|
r14 | super(); | |
|
cin
|
r9 | this.id = id || new Object(); | |
| } | |||
|
cin
|
r10 | protected emit(level: number, arg: any) { | |
|
cin
|
r14 | this._notify(new TraceEvent(this, level, arg)); | |
|
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
|
r14 | static on(handler: (source: TraceSource) => void) { | |
|
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; |