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 +45 -23

@@ -1,6 +1,7
1	import { IDestroyable, MapOf } from "../interfaces";	1	import { IDestroyable, MapOf } from "../interfaces";
2	import { argumentNotNull, isDestroyable } from "../safe";	2	import { argumentNotNull, isDestroyable } from "../safe";
3	import { ILifetimeManager } from "./interfaces";	3	import { ILifetimeManager, ILifetime } from "./interfaces";
		4	import { ActivationContext } from "./ActivationContext";
4		5
5	function safeCall(item: () => void) {	6	function safeCall(item: () => void) {
6	try {	7	try {
@@ -15,32 +16,53 export class LifetimeManager implements
15	private _cache: MapOf<any> = {};	16	private _cache: MapOf<any> = {};
16	private _destroyed = false;	17	private _destroyed = false;
17		18
18	has(id: string) {	19	initialize(id: string, context: ActivationContext<any>): ILifetime {
19	return id in this._cache;	20	const self = this;
20	}	21	let pending = false;
		22	return {
		23	has() {
		24	return (id in self._cache);
		25	},
		26
		27	get() {
		28	const t = self._cache[id];
		29	if (t === undefined)
		30	throw new Error(`The item with with the key ${id} isn't found`);
		31	return t;
		32	},
21		33
22	get(id: string) {	34	enter() {
23	const t = this._cache[id];	35	if (pending)
24	if (t === undefined)	36	throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
25	throw new Error(`The item with with the key ${id} isn't found`);	37	pending = true;
26	return t;	38	},
		39
		40	store(item: any, cleanup?: (item: any) => void) {
		41	argumentNotNull(id, "id");
		42	argumentNotNull(item, "item");
		43
		44	if (this.has())
		45	throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
		46	pending = false;
		47
		48	self._cache[id] = item;
		49
		50	if (self._destroyed)
		51	throw new Error("Lifetime manager is destroyed");
		52	if (cleanup) {
		53	self._cleanup.push(() => cleanup(item));
		54	} else if (isDestroyable(item)) {
		55	self._cleanup.push(() => item.destroy());
		56	}
		57	}
		58	};
27	}	59	}
28		60
29	register(id: string, item: any, cleanup?: (item: any) => void) {	61
30	argumentNotNull(id, "id");	62
31	argumentNotNull(item, "item");
32	if (this.has(id))
33	throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
34	this._cache[id] = item;
35		63
36	if (this._destroyed)	64
37	throw new Error("Lifetime manager is destroyed");	65
38	if (cleanup) {
39	this._cleanup.push(() => cleanup(item));
40	} else if (isDestroyable(item)) {
41	this._cleanup.push(() => item.destroy());
42	}
43	}
44		66
45	destroy() {	67	destroy() {
46	if (!this._destroyed) {	68	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