implab/implabjs-core Commit - r131:674555892e14

Refactoring, working on services lifetime

cin -

r131:674555892e14 ioc ts support

parent child

Context file:

r131:674555892e14

Collapse all files

src/main/ts/di/ActivationContext.ts +34 -49

             import { TraceSource } from "../log/TraceSource";
             import { argumentNotNull, argumentNotEmptyString } from "../safe";
-            import { Descriptor, ContainerProvided, ContainerServiceMap, ContainerKeys, ContainerResolve } from "./interfaces";
+            import { Descriptor, ContainerServiceMap, ContainerKeys, ContainerResolve } from "./interfaces";
             import { Container } from "./Container";
             import { MapOf } from "../interfaces";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
-            export interface ActivationContextInfo<S extends object> {
+            export interface ActivationContextInfo {
                 name: string;
                 service: string;
-                scope: ContainerServiceMap<S>;
             }
             export class ActivationContext<S extends object> {
                 _services: ContainerServiceMap<S>;
-                _stack: ActivationContextInfo<S>[];
                 _visited: MapOf<any>;
                 _name: string;
-                _localized: boolean = false;
+                _service: Descriptor<S, any>;
-                container: Container<S>;
+                _container: Container<S>;
+                _parent: ActivationContext<S> | undefined;
-                constructor(container: Container<S>, services: ContainerServiceMap<S>, name?: string, cache?: object, visited?: MapOf<any>) {
+                constructor(container: Container<S>, services: ContainerServiceMap<S>, name: string, service: Descriptor<S, any>) {
-                    argumentNotNull(container, "container");
+                    this._name = name;
-                    argumentNotNull(services, "services");
+                    this._service = service;
+                    this._visited = {};
-                    this._name = name || "<unnamed>";
+                    this._cache = {};
-                    this._visited = visited || {};
-                    this._stack = [];
-                    this._cache = cache || {};
                     this._services = services;
-                    this.container = container;
+                    this._container = container;
                 }
                 getName() {
                     return this._name;
                 }
+                getContainer() {
+                    return this._container;
+                }
                 resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>) {
                     const d = this._services[name];
                     this._services[name] = service as any;
                 }
-                clone() {
-                    return new ActivationContext<S>(
-                        this.container,
-                        this._services,
-                        this._name,
-                        this._cache,
-                        this._visited
-                    );
                 has(id: string) {
                     return id in this._cache;
                 }
                     if (trace.isLogEnabled())
                         trace.log(`enter ${name} ${d}`);
-                    this.enter(name, d.toString());
+                    const ctx = this.enter(d, name);
-                    const v = d.activate(this);
+                    const v = d.activate(ctx);
-                    this.leave();
                     if (trace.isLogEnabled())
                         trace.log(`leave ${name}`);
                     return count;
                 }
-                getStack() {
+                getStack(): ActivationContextInfo[] {
-                    return this._stack.slice().reverse();
+                    const stack = [{
+                        name: this._name,
+                        service: this._service.toString()
+                    }];
+                    return this._parent ?
+                        stack.concat(this._parent.getStack()) :
+                        stack;
                 }
-                private enter(name: string, service: string) {
+                private enter(service: Descriptor<S, any>, name: string): this {
-                    this._stack.push({
+                    const clone = Object.create(this);
-                        name,
+                    clone._name = name;
-                        service,
+                    clone._services = Object.create(this._services);
-                        scope: this._services
+                    clone._parent = this;
-                    });
+                    clone._service = service;
-                    this._name = name;
+                    return clone;
-                    this._services = Object.create(this._services);
-                private leave() {
-                    const ctx = this._stack.pop();
-                    if (ctx) {
-                        this._services = ctx.scope;
-                        this._name = ctx.name;
-                    } else {
-                        trace.error("Trying to leave the last activation scope");
                 }
             }

src/main/ts/di/Container.ts +13 -21

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
-            import { ServiceMap, Descriptor, PartialServiceMap, ContainerProvided, Resolver, ContainerServiceMap, ContainerKeys, ContainerResolve } from "./interfaces";
+            import { ServiceMap, Descriptor, PartialServiceMap, ContainerProvided, Resolver, ContainerServiceMap, ContainerKeys, ContainerResolve, ILifetimeManager } from "./interfaces";
             import { TraceSource } from "../log/TraceSource";
             import { Configuration, RegistrationMap } from "./Configuration";
             import { Cancellation } from "../Cancellation";
             import { MapOf, IDestroyable } from "../interfaces";
             import { isDescriptor } from "./traits";
+            import { LifetimeManager } from "./LifetimeManager";
+            import { each } from "../safe";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
                 readonly _cache: MapOf<any>;
+                readonly _lifetimeManager: ILifetimeManager;
                 readonly _cleanup: (() => void)[];
                 readonly _root: Container<S>;
                     this._root = parent ? parent.getRootContainer() : this;
                     this._services.container = new ValueDescriptor(this) as any;
                     this._disposed = false;
+                    this._lifetimeManager = new LifetimeManager();
                 }
                 getRootContainer() {
                     return this._parent;
                 }
+                getLifetimeManager() {
+                    return this._lifetimeManager;
+                }
                 resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>): ContainerResolve<S, K> {
                     trace.debug("resolve {0}", name);
                     const d = this._services[name];
                             throw new Error("Service '" + name + "' isn't found");
                     } else {
-                        const context = new ActivationContext<S>(this, this._services);
+                        const context = new ActivationContext<S>(this, this._services, String(name), d);
                         try {
-                            return context.activate(d, name.toString());
+                            return d.activate(context);
                         } catch (error) {
                             throw new ActivationError(name.toString(), context.getStack(), error);
                         }
                     if (arguments.length === 1) {
                         const data = nameOrCollection as ServiceMap<S>;
-                        for (const name in data) {
+                        each(data, (v, k) => this.register(k, v));
-                            if (Object.prototype.hasOwnProperty.call(data, name)) {
-                                this.register(name, data[name] as Descriptor<S, S[keyof S]>);
                     } else {
                         if (!isDescriptor(service))
                             throw new Error("The service parameter must be a descriptor");
                 createChildContainer<S2 extends object = S>(): Container<S & S2> {
                     return new Container<S & S2>(this as any);
                 }
-                has(id: string | number) {
-                    return id in this._cache;
-                get(id: string | number) {
-                    return this._cache[id];
-                store(id: string | number, value: any) {
-                    return (this._cache[id] = value);
             }

src/main/ts/di/LifetimeManager.ts +64 -15

@@ -7,16 +7,35 function safeCall(item: () => void) {
7	try {	7	try {
8	item();	8	item();
9	} catch {	9	} catch {
10	// silence	10	// silence!
11	}	11	}
12	}	12	}
13		13
		14	const emptyLifetime: ILifetime = {
		15	has() {
		16	return false;
		17	},
		18
		19	enter() {
		20
		21	},
		22
		23	get() {
		24	throw new Error("The specified item isn't registered with this lifetime manager");
		25	},
		26
		27	store() {
		28	// does nothing
		29	}
		30
		31	};
		32
14	export class LifetimeManager implements IDestroyable, ILifetimeManager {	33	export class LifetimeManager implements IDestroyable, ILifetimeManager {
15	private _cleanup: (() => void)[] = [];	34	private _cleanup: (() => void)[] = [];
16	private _cache: MapOf<any> = {};	35	private _cache: MapOf<any> = {};
17	private _destroyed = false;	36	private _destroyed = false;
18		37
19	initialize(id: string, ~~context~~: ~~ActivationContext~~<~~any~~>): ILifetime {	38	initialize(id: string): ILifetime {
20	const self = this;	39	const self = this;
21	let pending = false;	40	let pending = false;
22	return {	41	return {
@@ -58,12 +77,6 export class LifetimeManager implements
58	};	77	};
59	}	78	}
60		79
61
62
63
64
65
66
67	destroy() {	80	destroy() {
68	if (!this._destroyed) {	81	if (!this._destroyed) {
69	this._destroyed = true;	82	this._destroyed = true;
@@ -73,20 +86,56 export class LifetimeManager implements
73	}	86	}
74		87
75	static readonly empty: ILifetimeManager = {	88	static readonly empty: ILifetimeManager = {
76	has() {	89	initialize(): ILifetime {
77	return ~~fals~~e;	90	return emptyLifetime;
78	},	91	},
		92	destroy() {
		93	throw new Error("Trying to destroy empty lifetime manager, this is a bug.");
		94	}
		95
		96	};
		97
		98	static readonly hierarchyLifetime: ILifetimeManager = {
		99	initialize(id: string, context: ActivationContext<any>): ILifetime {
		100	return context.getContainer().getLifetimeManager().initialize(id, context);
		101	},
		102	destroy() {
		103	throw new Error("Trying to destroy hierarchy lifetime manager, this is a bug.");
		104	}
		105	};
79		106
80	get() {	107	static readonly singletonLifetime: ILifetimeManager = {
81	throw new Error("The specified item isn't registered with this lifetime manager");	108	initialize(id: string): ILifetime {
		109	return singletonLifetimeManager.initialize(id);
82	},	110	},
		111	destroy() {
		112	throw new Error("Trying to destroy singleton lifetime manager, this is a bug.");
		113	}
		114	};
83		115
84	register() {	116	static readonly contextLifetime: ILifetimeManager = {
85	// does nothing	117	initialize(id: string, context: ActivationContext<any>): ILifetime {
		118	return {
		119	enter() {
		120	if (context.visit(id))
		121	throw new Error("Cyclic reference detected");
		122	},
		123	get() {
		124	return context.get(id);
		125	},
		126	has() {
		127	return context.has(id);
		128	},
		129	store(item: any) {
		130	context.store(id, item);
		131	}
		132
		133	};
86	},	134	},
87
88	destroy() {	135	destroy() {
89	throw new Error("Trying to destroy empty lifetime manager, this is a bug.");	136	throw new Error("Trying to destroy empty lifetime manager, this is a bug.");
90	}	137	}
91	};	138	};
92	}	139	}
		140
		141	const singletonLifetimeManager = new LifetimeManager();

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

             import { ActivationContext } from "./ActivationContext";
-            import { Descriptor, ServiceMap, PartialServiceMap, ActivationType, ILifetimeManager } from "./interfaces";
+            import { Descriptor, ServiceMap, PartialServiceMap, ILifetimeManager } from "./interfaces";
             import { argumentNotNull, isPrimitive, keys, isNull } from "../safe";
             import { TraceSource } from "../log/TraceSource";
             import { isDescriptor } from "./traits";
             import { LifetimeManager } from "./LifetimeManager";
             import { MatchingMemberKeys } from "../interfaces";
+            import { Container } from "./Container";
             let cacheId = 0;
             };
             export interface ServiceDescriptorParams<S extends object, T, P extends any[]> {
-                lifetime: ILifetimeManager;
+                owner: Container<S>;
+                lifetime?: ILifetimeManager;
                 params?: P;
                 _lifetime = LifetimeManager.empty;
+                _owner: Container<S>;
                 constructor(opts: ServiceDescriptorParams<S, T, P>) {
-                    argumentNotNull(opts, "opts");
+                    argumentNotNull(opts && opts.owner, "opts.owner");
+                    this._owner = opts.owner;
                     if (opts.lifetime)
                         this._lifetime = opts.lifetime;

src/main/ts/di/interfaces.ts 0 -2

             export interface Descriptor<S extends object = any, T = any> {
                 activate(context: ActivationContext<S>): T;
-                clone(): this;
             }
             export type ServiceMap<S extends object> = {

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