implab/implabjs-core Commit - r129:c13384c6c1ac

working on lifetime management

cin -

r129:c13384c6c1ac ioc ts support

parent child

Context file:

r129:c13384c6c1ac

Collapse all files

src/main/ts/di/LifetimeManager.ts created 644 +70 0

@@ -0,0 +1,70
	1	import { IDestroyable, MapOf } from "../interfaces";
	2	import { argumentNotNull, isDestroyable } from "../safe";
	3	import { ILifetimeManager } from "./interfaces";
	4
	5	function safeCall(item: () => void) {
	6	try {
	7	item();
	8	} catch {
	9	// silence
	10	}
	11	}
	12
	13	export class LifetimeManager implements IDestroyable, ILifetimeManager {
	14	private _cleanup: (() => void)[] = [];
	15	private _cache: MapOf<any> = {};
	16	private _destroyed = false;
	17
	18	has(id: string) {
	19	return id in this._cache;
	20	}
	21
	22	get(id: string) {
	23	const t = this._cache[id];
	24	if (t === undefined)
	25	throw new Error(`The item with with the key ${id} isn't found`);
	26	return t;
	27	}
	28
	29	register(id: string, item: any, cleanup?: (item: any) => void) {
	30	argumentNotNull(id, "id");
	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
	36	if (this._destroyed)
	37	throw new Error("Lifetime manager is destroyed");
	38	if (cleanup) {
	39	this._cleanup.push(() => cleanup(item));
	40	} else if (isDestroyable(item)) {
	41	this._cleanup.push(() => item.destroy());
	42	}
	43	}
	44
	45	destroy() {
	46	if (!this._destroyed) {
	47	this._destroyed = true;
	48	this._cleanup.forEach(safeCall);
	49	this._cleanup.length = 0;
	50	}
	51	}
	52
	53	static readonly empty: ILifetimeManager = {
	54	has() {
	55	return false;
	56	},
	57
	58	get() {
	59	throw new Error("The specified item isn't registered with this lifetime manager");
	60	},
	61
	62	register() {
	63	// does nothing
	64	},
	65
	66	destroy() {
	67	throw new Error("Trying to destroy empty lifetime manager, this is a bug.");
	68	}
	69	};
	70	}

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

                 toString() {
                     return "@walk";
                 }
+                clone() {
+                    return this;
+                }
             }

src/main/ts/di/Container.ts +5 -2

             import { TraceSource } from "../log/TraceSource";
             import { Configuration, RegistrationMap } from "./Configuration";
             import { Cancellation } from "../Cancellation";
-            import { MapOf } from "../interfaces";
+            import { MapOf, IDestroyable } from "../interfaces";
             import { isDescriptor } from "./traits";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
-            export class Container<S extends object = any> implements Resolver<S> {
+            export class Container<S extends object = any> implements Resolver<S>, IDestroyable {
                 readonly _services: ContainerServiceMap<S>;
                 readonly _cache: MapOf<any>;
                     this._cleanup.push(callback);
                 }
+                destroy() {
+                    return this.dispose();
+                }
                 dispose() {
                     if (this._disposed)
                         return;

src/main/ts/di/FactoryServiceDescriptor.ts 0 -3

                     // bind to null
                     this._factory = (...args) => opts.factory.apply(null, args as any);
-                    if (opts.activation === "singleton") {
-                        this._cacheId = oid(opts.factory);
                 }
             }

src/main/ts/di/ServiceDescriptor.ts +29 -113

@@ -1,9 +1,10
1	import { ActivationContext } from "./ActivationContext";	1	import { ActivationContext } from "./ActivationContext";
2	import { Descriptor, ServiceMap, PartialServiceMap, ActivationType } from "./interfaces";	2	import { Descriptor, ServiceMap, PartialServiceMap, ActivationType, ILifetimeManager } from "./interfaces";
3	import { Container } from "./Container";
4	import { argumentNotNull, isPrimitive, keys, isNull } from "../safe";	3	import { argumentNotNull, isPrimitive, keys, isNull } from "../safe";
5	import { TraceSource } from "../log/TraceSource";	4	import { TraceSource } from "../log/TraceSource";
6	import { isDescriptor } from "./traits";	5	import { isDescriptor } from "./traits";
		6	import { LifetimeManager } from "./LifetimeManager";
		7	import { MatchingMemberKeys } from "../interfaces";
7		8
8	let cacheId = 0;	9	let cacheId = 0;
9		10
@@ -21,15 +22,14 function injectMethod<T, M extends keyof
21	return m.call(target, _parse(args, context, "." + method));	22	return m.call(target, _parse(args, context, "." + method));
22	}	23	}
23		24
24	function makeClenupCallback<T>(~~target~~: T, method: Cleaner<T>): () => ~~void~~;	25	function makeClenupCallback<T>(method: Cleaner<T>) {
25	function makeClenupCallback(target: any, method: any) {	26	if (typeof (method) === "function") {
26	if (typeof (method) === "string") {	27	return (target: T) => {
27	return () => {	28	method(target);
28	target[method]();
29	};	29	};
30	} else {	30	} else {
31	return () => {	31	return (target: T) => {
32	~~method~~(target);	32	(target[method] as any)();
33	};	33	};
34	}	34	}
35	}	35	}
@@ -53,16 +53,14 function _parse(value: any, context: Act
53	return t;	53	return t;
54	}	54	}
55		55
56	export type Cleaner<T> = ((x: T) => void) \| ~~keyof~~ ~~Extract~~<T, { [M in ~~keyof~~ T]: () => void }>;	56	export type Cleaner<T> = ((x: T) => void) \| MatchingMemberKeys<() => void, T>;
57		57
58	export type InjectionSpec<T> = {	58	export type InjectionSpec<T> = {
59	[m in keyof T]?: any;	59	[m in keyof T]?: any;
60	};	60	};
61		61
62	export interface ServiceDescriptorParams<S extends object, T, P extends any[]> {	62	export interface ServiceDescriptorParams<S extends object, T, P extends any[]> {
63	activation?: ActivationType;	63	lifetime: ILifetimeManager;
64
65	owner: Container<S>;
66		64
67	params?: P;	65	params?: P;
68		66
@@ -74,32 +72,23 export interface ServiceDescriptorParams
74	}	72	}
75		73
76	export class ServiceDescriptor<S extends object, T, P extends any[]> implements Descriptor<S, T> {	74	export class ServiceDescriptor<S extends object, T, P extends any[]> implements Descriptor<S, T> {
77	_instance: T \| undefined;
78
79	_hasInstance = false;
80
81	_activationType: ActivationType = "call";
82
83	_services: ServiceMap<S>;	75	_services: ServiceMap<S>;
84		76
85	_params: P \| undefined;	77	_params: P \| undefined;
86		78
87	_inject: InjectionSpec<T>[];	79	_inject: InjectionSpec<T>[];
88		80
89	_cleanup: ~~Cleaner~~<T> \| undefined;	81	_cleanup: ((item: T) => void) \| undefined;
90		82
91	_cacheId: any;	83	_cacheId = String(++cacheId);
92		84
93	_owner: Container<S>;	85	_lifetime = LifetimeManager.empty;
94		86
95	constructor(opts: ServiceDescriptorParams<S, T, P>) {	87	constructor(opts: ServiceDescriptorParams<S, T, P>) {
96	argumentNotNull(opts, "opts");	88	argumentNotNull(opts, "opts");
97	argumentNotNull(opts.owner, "owner");
98		89
99	this._owner = opts.owner;	90	if (opts.lifetime)
100		91	this._lifetime = opts.lifetime;
101	if (!isNull(opts.activation))
102	this._activationType = opts.activation;
103		92
104	if (!isNull(opts.params))	93	if (!isNull(opts.params))
105	this._params = opts.params;	94	this._params = opts.params;
@@ -113,96 +102,22 export class ServiceDescriptor<S extends
113	throw new Error(	102	throw new Error(
114	"The cleanup parameter must be either a function or a function name");	103	"The cleanup parameter must be either a function or a function name");
115		104
116	this._cleanup = opts.cleanup;	105	this._cleanup = makeClenupCallback(opts.cleanup);
117	}	106	}
118	}	107	}
119		108
120	activate(context: ActivationContext<S>) {	109	activate(context: ActivationContext<S>) {
121	// if we have a local service records, register them first	110	const lifetime = this._lifetime.initialize(this._cacheId, context);
122	let instance: T;
123
124	// ensure we have a cache id
125	if (!this._cacheId)
126	this._cacheId = ++cacheId;
127
128	switch (this._activationType) {
129	case "singleton": // SINGLETON
130	// if the value is cached return it
131	if (this._hasInstance)
132	return this._instance;
133
134	// singletons are bound to the root container
135	const container = context.container.getRootContainer();
136
137	if (container.has(this._cacheId)) {
138	instance = container.get(this._cacheId);
139	} else {
140	instance = this._create(context);
141	container.store(this._cacheId, instance);
142	if (this._cleanup)
143	container.onDispose(
144	makeClenupCallback(instance, this._cleanup));
145	}
146
147	this._hasInstance = true;
148	return (this._instance = instance);
149
150	case "container": // CONTAINER
151	// return a cached value
152
153	if (this._hasInstance)
154	return this._instance;
155
156	// create an instance
157	instance = this._create(context);
158		111
159	// the instance is bound to the container	112	if (lifetime.has()) {
160	if (this._cleanup)	113	return lifetime.get();
161	this._owner.onDispose(	114	} else {
162	makeClenupCallback(instance, this._cleanup));	115	const instance = this._create(context);
163		116	lifetime.store(this._cacheId, this._cleanup);
164	~~// cache and~~ return ~~the~~ instance	117	return instance;
165	this._hasInstance = true;
166	return (this._instance = instance);
167	case "context": // CONTEXT
168	// return a cached value if one exists
169
170	if (context.has(this._cacheId))
171	return context.get(this._cacheId);
172	// context context activated instances are controlled by callers
173	return context.store(this._cacheId, this._create(context));
174	case "call": // CALL
175	// per-call created instances are controlled by callers
176	return this._create(context);
177	case "hierarchy": // HIERARCHY
178	// hierarchy activated instances are behave much like container activated
179	// except they are created and bound to the child container
180
181	// return a cached value
182	if (context.container.has(this._cacheId))
183	return context.container.get(this._cacheId);
184
185	instance = this._create(context);
186
187	if (this._cleanup)
188	context.container.onDispose(makeClenupCallback(
189	instance,
190	this._cleanup));
191
192	return context.container.store(this._cacheId, instance);
193	default:
194	throw new Error("Invalid activation type: " + this._activationType);
195	}	118	}
196	}	119	}
197		120
198	isInstanceCreated() {
199	return this._hasInstance;
200	}
201
202	getInstance() {
203	return this._instance;
204	}
205
206	_factory(...params: any[]): T {	121	_factory(...params: any[]): T {
207	throw Error("Not implemented");	122	throw Error("Not implemented");
208	}	123	}
@@ -210,10 +125,6 export class ServiceDescriptor<S extends
210	_create(context: ActivationContext<S>) {	125	_create(context: ActivationContext<S>) {
211	trace.debug(`constructing ${context._name}`);	126	trace.debug(`constructing ${context._name}`);
212		127
213	if (this._activationType !== "call" &&
214	context.visit(this._cacheId) > 0)
215	throw new Error("Recursion detected");
216
217	if (this._services) {	128	if (this._services) {
218	keys(this._services).forEach(p => context.register(p, this._services[p]));	129	keys(this._services).forEach(p => context.register(p, this._services[p]));
219	}	130	}
@@ -236,4 +147,9 export class ServiceDescriptor<S extends
236	}	147	}
237	return instance;	148	return instance;
238	}	149	}
		150
		151	clone() {
		152	return Object.create(this);
		153	}
		154
239	}	155	}

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

                 visitFactoryRegistration(): void;
-                visitBuilder<T>(builder: (t: ServiceRecordBuilder<T, S>) => void): void;
             }
             export interface RegistrationBuilder<T, S extends object> {

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

             import { ActivationContext } from "./ActivationContext";
+            import { IDestroyable } from "../interfaces";
             export interface Descriptor<S extends object = any, T = any> {
                 activate(context: ActivationContext<S>): T;
+                clone(): this;
             }
             export type ServiceMap<S extends object> = {
                 Exclude<S, ContainerProvided<S>>;
             export type ActivationType = "singleton" | "container" | "hierarchy" | "context" | "call";
+            export interface ILifetimeManager extends IDestroyable {
+                initialize(id: string, context: ActivationContext<any>): ILifetime;
+            }
+            export interface ILifetime {
+                has(): boolean;
+                get(): any;
+                store(item: any, cleanup?: (item: any) => void): void;
+            }
  No newline at end of file

src/main/ts/interfaces.ts +8 0

             export type Predicate<T = any> = (x: T) => boolean;
+            export type MatchingMemberKeys<T, From> = { [K in keyof From]: From[K] extends T ? K : never}[keyof From];
+            export type NotMatchingMemberKeys<T, From> = { [K in keyof From]: From[K] extends T ? never : K}[keyof From];
+            export type ExtractMembers<T, From> = Pick<From, MatchingMemberKeys<T, From>>;
+            export type ExcludeMembers<T, From> = Pick<From, NotMatchingMemberKeys<T, From>>;
             export interface MapOf<T> {
                 [key: string]: T;
             }

src/main/ts/safe.ts +7 -1

-            import { ICancellable, Constructor } from "./interfaces";
+            import { ICancellable, Constructor, IDestroyable } from "./interfaces";
             import { Cancellation } from "./Cancellation";
             let _nextOid = 0;
                 }
             }
+            export function isDestroyable(d: any): d is IDestroyable {
+                if (d && "destroy" in d && typeof(destroy) === "function")
+                    return true;
+                return false;
+            }
             export function destroy(d: any) {
                 if (d && "destroy" in d)
                     d.destroy();

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