implab/implabjs-core Commit - r148:cd81c631015f

Fixed circular dependency TraceSource<->Registry

cin -

r148:cd81c631015f v1.4.0-rc6 default

parent child

Context file:

r148:cd81c631015f

Collapse all files

src/main/ts/log/Registry.ts +5 -5

             import { TraceSource } from "./TraceSource";
             import { argumentNotNull } from "../safe";
             import { IDestroyable, MapOf } from "../interfaces";
             export class Registry {
                 static readonly instance = new Registry();
                 private _registry: MapOf<TraceSource> = {};
                 private _listeners: MapOf<(source: TraceSource) => void> = {};
                 private _nextCookie: number = 1;
                 get(id: string): TraceSource {
                     argumentNotNull(id, "id");
                     if (this._registry[id])
                         return this._registry[id];
+                    else
+                        throw new Error("The specified trace source doesn't exists");
+                }
-                    const source = new TraceSource(id);
+                has(id: string) {
-                    this._registry[id] = source;
+                    return !!this._registry[id];
-                    this._onNewSource(source);
-                    return source;
                 }
                 add(id: any, source: TraceSource) {
                     argumentNotNull(id, "id");
                     argumentNotNull(source, "source");
                     this._registry[id] = source;
                     this._onNewSource(source);
                 }
                 _onNewSource(source: TraceSource) {
                     for (const i in this._listeners)
                         this._listeners[i].call(null, source);
                 }
                 on(handler: (source: TraceSource) => void): IDestroyable {
                     argumentNotNull(handler, "handler");
                     const me = this;
                     const cookie = this._nextCookie++;
                     this._listeners[cookie] = handler;
                     for (const i in this._registry)
                         handler(this._registry[i]);
                     return {
                         destroy() {
                             delete me._listeners[cookie];
                         }
                     };
                 }
             }

src/main/ts/log/TraceSource.ts +6 0

             import { Observable } from "../Observable";
             import { Registry } from "./Registry";
             import { TraceEventData } from "./TraceEventData";
             import { EventProvider } from "../EventProvider";
             export const DebugLevel = 400;
             export const LogLevel = 300;
             export const WarnLevel = 200;
             export const ErrorLevel = 100;
             export const SilentLevel = 0;
             export interface TraceEvent {
                 readonly source: TraceSource;
                 readonly level: number;
                 readonly message: any;
                 readonly args?: any[];
             }
             export class TraceSource {
                 readonly id: any;
                 level = 0;
                 readonly events: Observable<TraceEvent>;
                 private readonly _provider: EventProvider<TraceEvent>;
                 constructor(id?: any) {
                     this.id = id || new Object();
                     this._provider = new EventProvider();
                     this.events = this._provider.getObservable();
                 }
                 protected emit(level: number, message: any, args: any[]) {
                     this._provider.post(new TraceEventData(this, level, message, args));
                 }
                 isDebugEnabled() {
                     return this.level >= DebugLevel;
                 }
                 debug(data: any): void;
                 debug(msg: string, ...args: any[]): void;
                 debug(msg: string, ...args: any[]) {
                     if (this.isEnabled(DebugLevel))
                         this.emit(DebugLevel, msg, args);
                 }
                 isLogEnabled() {
                     return this.level >= LogLevel;
                 }
                 log(data: any): void;
                 log(msg: string, ...args: any[]): void;
                 log(msg: string, ...args: any[]) {
                     if (this.isEnabled(LogLevel))
                         this.emit(LogLevel, msg, args);
                 }
                 isWarnEnabled() {
                     return this.level >= WarnLevel;
                 }
                 warn(data: any): void;
                 warn(msg: string, ...args: any[]): void;
                 warn(msg: string, ...args: any[]) {
                     if (this.isEnabled(WarnLevel))
                         this.emit(WarnLevel, msg, args);
                 }
                 /**
                  * returns true if errors will be recorded.
                  */
                 isErrorEnabled() {
                     return this.level >= ErrorLevel;
                 }
                 /** Traces a error
                  * @param data The object which will be passed to the underlying listeners
                  */
                 error(data: any): void;
                 /**
                  * Traces a error.
                  *
                  * @param msg the message.
                  * @param args parameters which will be substituted in the message.
                  */
                 error(msg: string, ...args: any[]): void;
                 error(msg: string, ...args: any[]) {
                     if (this.isEnabled(ErrorLevel))
                         this.emit(ErrorLevel, msg, args);
                 }
                 /**
                  * Checks whether the specified level is enabled for this
                  * trace source.
                  *
                  * @param level the trace level which should be checked.
                  */
                 isEnabled(level: number) {
                     return (this.level >= level);
                 }
                 /**
                  * Traces a raw event, passing data as it is to the underlying listeners
                  *
                  * @param level the level of the event
                  * @param msg the data of the event, can be a simple string or any object.
                  */
                 traceEvent(level: number, msg: any, ...args: any[]) {
                     if (this.isEnabled(level))
                         this.emit(level, msg, args);
                 }
                 /**
                  * 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
                  */
                 static on(handler: (source: TraceSource) => void) {
                     return Registry.instance.on(handler);
                 }
                 /**
                  * Creates or returns already created trace source for the specified id.
                  *
                  * @param id the id for the trace source
                  */
                 static get(id: any) {
+                    if (!Registry.instance.has(id)) {
+                        const trace = new TraceSource(id);
+                        Registry.instance.add(id, trace);
+                        return trace;
+                    } else {
                         return Registry.instance.get(id);
                     }
                 }
+            }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages