implab/implabjs-core Commit - r130:1af015b1d265

working on services lifetime

cin -

r130:1af015b1d265 ioc ts support

parent child

Context file:

r130:1af015b1d265

Collapse all files

src/main/ts/di/LifetimeManager.ts +35 -13

             import { IDestroyable, MapOf } from "../interfaces";
             import { argumentNotNull, isDestroyable } from "../safe";
-            import { ILifetimeManager } from "./interfaces";
+            import { ILifetimeManager, ILifetime } from "./interfaces";
+            import { ActivationContext } from "./ActivationContext";
             function safeCall(item: () => void) {
                 try {
                 private _cache: MapOf<any> = {};
                 private _destroyed = false;
-                has(id: string) {
+                initialize(id: string, context: ActivationContext<any>): ILifetime {
-                    return id in this._cache;
+                    const self = this;
+                    let pending = false;
+                    return {
+                        has() {
+                            return (id in self._cache);
+                        },
-                get(id: string) {
+                        get() {
-                    const t = this._cache[id];
+                            const t = self._cache[id];
                             if (t === undefined)
                                 throw new Error(`The item with with the key ${id} isn't found`);
                             return t;
+                        },
-                register(id: string, item: any, cleanup?: (item: any) => void) {
+                        enter() {
+                            if (pending)
+                                throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
+                            pending = true;
+                        },
+                        store(item: any, cleanup?: (item: any) => void) {
                             argumentNotNull(id, "id");
                             argumentNotNull(item, "item");
-                    if (this.has(id))
+                            if (this.has())
                                 throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
-                    this._cache[id] = item;
+                            pending = false;
-                    if (this._destroyed)
+                            self._cache[id] = item;
+                            if (self._destroyed)
                                 throw new Error("Lifetime manager is destroyed");
                             if (cleanup) {
-                        this._cleanup.push(() => cleanup(item));
+                                self._cleanup.push(() => cleanup(item));
                             } else if (isDestroyable(item)) {
-                        this._cleanup.push(() => item.destroy());
+                                self._cleanup.push(() => item.destroy());
                             }
                         }
+                    };
+                }
                 destroy() {
                     if (!this._destroyed) {

src/main/ts/di/ServiceDescriptor.ts +5 -3

                     return m.call(target, _parse(args, context, "." + method));
             }
-            function makeClenupCallback<T>(method: Cleaner<T>) {
+            function makeCleanupCallback<T>(method: Cleaner<T>) {
                 if (typeof (method) === "function") {
                     return (target: T) => {
                         method(target);
                     };
                 } else {
                     return (target: T) => {
-                        (target[method] as any)();
+                        const m = target[method] as any;
+                        m.apply(target);
                     };
                 }
             }
                             throw new Error(
                                 "The cleanup parameter must be either a function or a function name");
-                        this._cleanup = makeClenupCallback(opts.cleanup);
+                        this._cleanup = makeCleanupCallback(opts.cleanup);
                     }
                 }
                     if (lifetime.has()) {
                         return lifetime.get();
                     } else {
+                        lifetime.enter();
                         const instance = this._create(context);
                         lifetime.store(this._cacheId, this._cleanup);
                         return instance;

src/main/ts/di/interfaces.ts +4 0

             export interface ILifetime {
                 has(): boolean;
                 get(): any;
+                enter(): void;
                 store(item: any, cleanup?: (item: any) => void): void;
             }

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